leetCode 3 Longest Substring Without Repeating Characters
給定一個字串，找到沒有重複字元的最長子串，返回它的長度。
解法一
簡單粗暴些，找一個最長子串，那麼我們用兩個迴圈窮舉所有子串，然後再用一個函式判斷該子串中有沒有重複的字元。
public int lengthOfLongestSubstring(String s) {
int n = s.length();
int ans = 0;//儲存當前得到滿足條件的子串的最大值
for (int i = 0; i < n; i++)
for (int j = i + 1; j <= n; j++) //之所以 j<= n，是因為我們子串是 [i,j),左閉右開
if (allUnique(s, i, j)) ans = Math.max(ans, j - i); //更新 ans
return ans;
}
public boolean allUnique(String s, int start, int end) {
Set<Character> set = new HashSet<>();//初始化 hash set
for (int i = start; i < end; i++) {//遍歷每個字元
Character ch = s.charAt(i);
if (set.contains(ch)) return false; //判斷字元在不在 set 中
set.add(ch);//不在的話將該字元新增到 set 裡邊
}
return true;
}
複製程式碼
時間複雜度：兩個迴圈，加上判斷子串滿足不滿足條件的函式中的迴圈，O（n³）。
空間複雜度：使用了一個 set，判斷子串中有沒有重複的字元。由於 set 中沒有重複的字元，所以最長就是整個字符集，假設字符集的大小為 m ，那麼 set 最長就是 m 。另一方面，如果字串的長度小於 m ，是 n 。那麼 set 最長也就是 n 了。綜上，空間複雜度為 O（min（m，n））。
解法二
遺憾的是上邊的演算法沒有通過 leetCode，時間複雜度太大，造成了超時。我們怎麼來優化一下呢？
上邊的演算法中，我們假設當 i 取 0 的時候，
j 取 1，判斷字串 str[0,1) 中有沒有重複的字元。
j 取 2，判斷字串 str[0,2) 中有沒有重複的字元。
j 取 3，判斷字串 str[0,3) 中有沒有重複的字元。
j 取 4，判斷字串 str[0,4) 中有沒有重複的字元。
做了很多重複的工作，因為如果 str[0,3) 中沒有重複的字元，我們不需要再判斷整個字串 str[0,4) 中有沒有重複的字元，而只需要判斷 str[3] 在不在 str[0,3) 中，不在的話，就表明 str[0,4) 中沒有重複的字元。
如果在的話，那麼 str[0,5) ，str[0,6) ，str[0,7) 一定有重複的字元，所以此時後邊的 j 也不需要繼續增加了。i ++ 進入下次的迴圈就可以了。
此外，我們的 j 也不需要取 j + 1，而只需要從當前的 j 開始就可以了。
綜上，其實整個關於 j 的迴圈我們完全可以去掉了，此時可以理解變成了一個「滑動視窗」。
整體就是橘色視窗在依次向右移動。
判斷一個字元在不在字串中，我們需要可以遍歷整個字串，遍歷需要的時間複雜度就是 O（n），加上最外層的 i 的迴圈，總體複雜度就是 O（n²）。我們可以繼續優化，判斷字元在不在一個字串，我們可以將已有的字串存到 Hash 裡，這樣的時間複雜度是 O（1），總的時間複雜度就變成了 O（n）。
public class Solution {
public int lengthOfLongestSubstring(String s) {
int n = s.length();
Set<Character> set = new HashSet<>();
int ans = 0, i = 0, j = 0;
while (i < n && j < n) {
if (!set.contains(s.charAt(j))){
set.add(s.charAt(j++));
ans = Math.max(ans, j - i);
}
else {
set.remove(s.charAt(i++));
}
}
return ans;
}
}
複製程式碼
時間複雜度：在最壞的情況下，while 迴圈中的語句會執行 2n 次，例如 abcdefgg，開始的時候 j 一直後移直到到達第二個 g 的時候固定不變 ，然後 i 開始一直後移直到 n ，所以總共執行了 2n 次，時間複雜度為 O（n）。
空間複雜度：和上邊的類似，需要一個 Hash 儲存子串，所以是 O（min（m，n））。
解法三
繼續優化，我們看上邊的演算法的一種情況。
當 j 指向的 c 存在於前邊的子串 abcd 中，此時 i 向前移到 b ,此時子串中仍然含有 c，還得繼續移動，所以這裡其實可以優化。我們可以一步到位，直接移動到子串 c 的位置的下一位！
實現這樣的話，我們將 set 改為 map ，將字元存為 key ，將對應的下標存到 value 裡就實現了。
public class Solution {
public int lengthOfLongestSubstring(String s) {
int n = s.length(), ans = 0;
Map<Character, Integer> map = new HashMap<>();
for (int j = 0, i = 0; j < n; j++) {
if (map.containsKey(s.charAt(j))) {
i = Math.max(map.get(s.charAt(j)), i);
}
ans = Math.max(ans, j - i + 1);
map.put(s.charAt(j), j + 1);//下標 + 1 代表 i 要移動的下個位置
}
return ans;
}
}
複製程式碼
與解法二相比
由於採取了 i 跳躍的形式，所以 map 之前存的字元沒有進行 remove ，所以 if 語句中進行了Math.max ( map.get ( s.charAt ( j ) ) , i )，要確認得到的下標不是 i 前邊的。
還有個不同之處是 j 每次迴圈都進行了自加 1 ，因為 i 的跳躍已經保證了 str[ i , j] 內沒有重複的字串，所以 j 直接可以加 1 。而解法二中，要保持 j 的位置不變，因為不知道和 j 重複的字元在哪個位置。
最後個不同之處是， ans 在每次迴圈中都進行更新，因為 ans 更新前 i 都進行了更新，已經保證了當前的子串符合條件，所以可以更新 ans 。而解法二中，只有噹噹前的子串不包含當前的字元時，才進行更新。
時間複雜度：我們將 2n 優化到了 n ，但最終還是和之前一樣，O（n）。
空間複雜度：也是一樣的，O（min（m，n)）。
解法四
和解法三思路一樣，區別的地方在於，我們不用 Hash ，而是直接用陣列，字元的 ASCII 碼值作為陣列的下標，陣列儲存該字元所在字串的位置。適用於字符集比較小的情況，因為我們會直接開闢和字符集等大的陣列。
public class Solution {
public int lengthOfLongestSubstring(String s) {
int n = s.length(), ans = 0;
int[] index = new int[128];
for (int j = 0, i = 0; j < n; j++) {
i = Math.max(index[s.charAt(j)], i);
ans = Math.max(ans, j - i + 1);
index[s.charAt(j)] = j + 1;//（下標 + 1） 代表 i 要移動的下個位置
}
return ans;
}
}
複製程式碼
和解法 3 不同的地方在於，沒有了 if 的判斷，因為如果 index[ s.charAt ( j ) ] 不存在的話，它的值會是 0 ，對最終結果不會影響。
時間複雜度：O（n）。
空間複雜度：O（m），m 代表字符集的大小。這次不論原字串多小，都會利用這麼大的空間。
總結
綜上，我們一步一步的尋求可優化的地方，對演算法進行了優化。又加深了 Hash 的應用，以及利用陣列巧妙的實現了 Hash 的作用。