Leetcode 3. 无重复字符的最长子串

3. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

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

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

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

示例 4:
输入: s = “”
输出: 0

一共有五种解题方法：

// ASCII
    public int lengthOfLongestSubstring(String s) {
        int[] charMap = new int[256];
        Arrays.fill(charMap, 0);
        int start = 0, maxLen = 0;
        for (int j = 0; j < s.length(); j++) {
            if (charMap[s.charAt(j)] > start) {
                start = charMap[s.charAt(j)];
            }
            charMap[s.charAt(j)] = j+1;
            maxLen = Math.max(j + 1 - start , maxLen);
        }
        return maxLen;
    }
    
    // hashmap
    public int lengthOfLongestSubstring2(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); // current index of character
        int start = 0;
        for (int j = 0; j < n; j++) {
            if (map.containsKey(s.charAt(j)) && map.get(s.charAt(j)) >= start) {
                start = map.get(s.charAt(j))+1;
            }
            map.put(s.charAt(j), j);
            ans = Math.max(ans, j - start + 1);

        }
        return ans;
    }


    //滑动窗口解法1：Hashset1+Hashset2
    // for循环代替右指针，右指针一直往前，再移动左指针
    // Hashset1
    public int lengthOfLongestSubstring3(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        while (i < n && j < n) {
            // try to extend the range [i, j]
            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;
    }

    // Hashset2
    public int lengthOfLongestSubstring4(String s) {
        int n = s.length();
        Set<Character> set = new HashSet<>();
        char[] chars = s.toCharArray();
        int left = 0, ans = 0;

        for(int i =0; i<n; i++){
            while(set.contains(chars[i])){
                set.remove(chars[left]);
                left++;
            }
            set.add(chars[i]);
            ans = Math.max(ans, set.size());
        }


        return ans;
    }

   //滑动窗口解法2：for循环代替左指针，for循环里右指针先移动到最大，然后再移动for循环（左指针）到临界，再移动右指针
    public int lengthOfLongestSubstring(String s) {
        // 哈希集合，记录每个字符是否出现过
        Set<Character> occ = new HashSet<Character>();
        int n = s.length();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.remove(s.charAt(i - 1));
            }
            while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
                // 不断地移动右指针
                occ.add(s.charAt(rk + 1));
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = Math.max(ans, rk - i + 1);
        }
        return ans;
    }

总结一下，基本是双指针解法或者是单指针+for循环！