面试题48. 最长不含重复字符的子字符串（Java）（List）（HashSet）（HashMap）

1 题目

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

提示：

s.length <= 40000
注意：本题与主站 3 题相同：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2 Java

必须要用一个容器存储连续且无重复的字符段，该容器的作用是用来判断是否已包含新字符，自己查找复杂度过高
可以用List、Set、Map三种
显然Set、Map在查找上更有优势
但由于本题快速解法是利用滑动窗口，Set无序，可能还不够好
Map虽然也无序，但可以利用value保存索引

2.1 方法一（暴力）

用HashSet存储当前不重复的字符段，查找速度快

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int ans = 0;
        for(int i = 0; i < s.length(); i++){
            HashSet<Character> set = new HashSet<>();
            int j = i;
            while(j < s.length() && !set.contains(s.charAt(j))){
                set.add(s.charAt(j));
                j++;
            }
            ans = Math.max(ans, j - i);
        }
        return ans;
    }
}

2.2 方法二（List）

滑动窗口，当遍历到当前元素字符段中已存在，窗口左端移动到存在的元素后一个位置，

迭代器的意义在于帮助集合删除
Iterator it = list.iterator(); it.hasNext(); it.next(); it.remove();
List可以截取一部分，返回一个List类型，但返回的是原list的镜像显示，改变新list会影响原list，而且这玩意很慢，不建议用（因为原list不清零，一直增长）
list.subList(k + 1, list.size());

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int maxL = 0;
        List<Character> list = new ArrayList<>();

        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            // 若list中包含该字符
            if(list.contains(c)){
                // 获取子字符串左端
                int l = list.indexOf(c);
                // 更新list；删除前半部分，截取后半部分；以list中 与当前字符相同的字符 作为前、后部分的划分
                list = new ArrayList<>(list.subList(l + 1, list.size()));
            }
            // list存储当前字符
            list.add(c);
            // 更新最长子字符串的长度
            maxL = Math.max(maxL, list.size());
        }

        return maxL;
    }
}

2.3 方法三（HashSet）

i和j作为字符串s的双指针，若set不含s[j]，窗口右端向右扩展一格；若set含s[j]，窗口左端向右缩进一格

class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashSet<Character> set = new HashSet<>();
        int maxL = 0, l = 0, r = 0;

        // 以窗口右端r为标准，遍历字符串
        while(r < s.length()){
            // 若set中不含r字符，窗口右端向右扩展一格
            if(!set.contains(s.charAt(r))){
                set.add(s.charAt(r++));
                maxL = Math.max(maxL, r - l);
            }
            // 若set中含r字符，窗口左端向右缩进一格
            else    set.remove(s.charAt(l++));
        }

        return maxL;
    }
}

2.4 方法四（HashMap）

HashMap的value存对应字符在s中的序号，每遍历s得到一个新字符，都会更新窗口左右端（i和j）。处理完窗口范围，更新窗口最大长度，更新Map

HashMap窗口左端可以一步到位，不需要一步一步向右移动，且边移动边删除元素

class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap<>();
        int maxL = 0, l = 0;

        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            // 若map中包含该字符
            if(map.containsKey(c)){
                // 更新子字符串左端
                // l = map.get(c) + 1;  // ！！！这个写法是错的，比如abba，遍历到最后一个a时，map.get(c) = 0，显然不对
                l = Math.max(l, map.get(c) + 1);
            }
            // map存储当前字符
            map.put(c, i);
            // 更新最长子字符串；每次遍历都更新
            maxL = Math.max(maxL, i - l + 1);
        }

        return maxL;
    }
}

3 总结

List：
优点有序；
缺点必须删除重复元素之前的所有，否则没法contains，但list恰恰没有一次删除一段的API。并且查找相对慢
HashSet：
优点查找快；
缺点无序，且同样是必须删除重复元素之前的所有
HashMap：
优点查找快，且可以存一个value，解决了无序的弊端