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