Java 字符串String（一）拆分

在java語言中，String是一個包含char數組、其餘字段，方法組成的java類。而在咱們的coding生涯中，字符串又每每是咱們最常也是最多打交道的，所以下面的一些經常使用的方法列舉一下：

toCharArray()//將此字符串轉換爲一個新的字符數組
Arrays.sort()//對數組進行排序
Arrays.toString(char[] a)//返回指定數組內容的字符串表示形式
charAt(int index)//        //返回指定索引出的char值
length()//返回此字符串的長度
substring(int beginIndex)    //返回一個新字符串，是原字符串的子串
substring(int beginIndex, int endIndex)//同上
Integer.valueOf(String s)// 返回的是一個Integer對象
String.valueOf(int i)//返回int參數的字符串表示形式

接下來一個小問題:

Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence of one or more dictionary words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

一、拿到這個題目，我一想首先到腦子的是遍歷，挨個遍歷一番，把指定的字符串從0到length來一下，看看與字典是否同樣，同樣的話就從這個index到length再比較一下。若是同樣，那麼就OK

下面是我本身寫的搓搓的代碼， 下面是調用的

 1 public boolean divisionString (String targetS, String[] dict){
 2         String temp = null;
 3         int tmpi =0;    //標識以及一部分匹配後，下一個的beginIndex
 4         for(int i=1; i<= targetS.length(); i++){
 5             if(tmpi == 0){
 6                 temp = targetS.substring(0, i);
 7             }else{
 8                 temp=targetS.substring(tmpi, i);
 9             }
10             for(int j=0; j< dict.length; j++){
11                 if(temp.equals(dict[j])){
12                     tmpi=i;    //首次或者下次匹配後，next的beginIndex
13                     break;
14                 }
15             }
16         }
17         if(tmpi == targetS.length()){    //最後tmpi確定要等於要鑑定的字符串的長度咯
18             return true;
19         }else{
20             return false;
21         }
22     }

二、不過當我看到網頁例子的時候他的解法可能要比個人好那麼一點

請看下面代碼：

 1     public boolean wordBreak(String s, Set<String> dict) {
 2         boolean[] t = new boolean[s.length()+1];
 3         t[0] = true; //set first to be true, why?
 4         //Because we need initial state
 5  
 6         for(int i=0; i<s.length(); i++){
 7             //should continue from match position
 8             if(!t[i]) 
 9                 continue;
10  
11             for(String a: dict){
12                 int len = a.length();
13                 int end = i + len;
14                 if(end > s.length())
15                     continue;
16  
17                 if(t[end]) continue;
18  
19                 if(s.substring(i, end).equals(a)){
20                     t[end] = true;
21                 }
22             }
23         }
24         return t[s.length()];
25     }

看了一下這個思路的重點是以dict的內容和長度來對字符串比較，切割字符串的次數比我上個代碼少了不少，效率上來講的話，若是數據量大了的話應該會明顯好，

其實上面兩個方法已經默認用到了Dynamic Programming方法，因此有時候algorithm這個東西又沒有咱們想的那麼難

三、題目給的最基本的作法是一個遞歸，這裏也把代碼貼過來吧， 其實我蠻不喜歡遞歸這個東東的！

 1         public boolean wordBreakNative(String s, Set<String> dict) {
 2                  return wordBreakHelper(s, dict, 0);
 3         }
 4      
 5         public boolean wordBreakHelper(String s, Set<String> dict, int start){
 6             if(start == s.length()) 
 7                 return true;
 8      
 9             for(String a: dict){
10                 int len = a.length();
11                 int end = start+len;
12      
13                 //end index should be <= string length
14                 if(end > s.length()) 
15                     continue;
16      
17                 if(s.substring(start, start+len).equals(a))
18                     if(wordBreakHelper(s, dict, start+len))
19                         return true;
20             }
21      
22             return false;
23         }

但願有人能提出更好的方法！！