leetCode 3 Longest Substring Without Repeating Characters

https://leetcode.windliang.cc/ 第一時間發佈

題目描述（中等難度）

給定一個字符串，找到沒有重複字符的最長子串，返回它的長度。

解法一

簡單粗暴些，找一個最長子串，那麼咱們用兩個循環窮舉全部子串，而後再用一個函數判斷該子串中有沒有重複的字符。

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 的做用。