LeetCode 3. 无重复字符的最长子串 (滑动窗口&哈希表)

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

题意：

• 找子串
• 子串中无重复字符
• 要求子串长度最长

解法1（暴力法）

思路：

• 建立一个长度不断变小的滑动窗口
• 用一个指针指针扫描窗口内的每个元素：
  • 如果除去指针指向的那个元素，窗口内仍有与其相同的字符则停止扫描
• 只要上面的窗口扫描指针大于了窗口的endIndex，则说明该窗口内无相同字符
• 返回该窗口长度即为ans

class Solution {
    public static int lengthOfLongestSubstring(String s) {
        if(s.equals("")) return 0;
        int len = s.length();
        char[] c = s.toCharArray();
        while (len >= 2) {
            for (int startIndex = 0; startIndex < s.length(); startIndex++) {
                int endIndex;
                if ((endIndex = startIndex + len - 1) > s.length() - 1) break;
                int p = startIndex;
                while (p <= endIndex) {
                	// 保存指针指向的那个字符值
                    char temp = c[p];
                    // 除去窗口内指针指向的那个字符值
                    c[p] = 0;
                    // 判断窗口内是否有与除去指针指向的那个值相同的字符
                    if (search(c, startIndex, endIndex, temp)) {
                    	// 恢复
                        c[p] = temp;
                        break;
                    }
                    // 恢复
                    c[p] = temp;
                    p++;
                }
                if (p > endIndex) return len;
            }
            len--;
        }
        return 1;
    }

    public static boolean search(char[] c, int startIndex, int endIndex, char temp) {
        for (int i = startIndex; i <= endIndex; i++) {
            if (c[i] == temp) return true;
        }
        return false;
    }
}

在判断是否有相同字符上优化：

• 使用HashSet
• 把窗口内的字符保存在HashSet中
• 只要HashSet的size与窗口长度相同则说明该窗口内无重复字符

    public static int lengthOfLongestSubstring(String s) {
        if (s.equals("")) return 0;
        int len = s.length();
        char[] c = s.toCharArray();
        HashSet<Character> set = new HashSet<>();
        while (len >= 2) {
            for (int startIndex = 0; startIndex < s.length(); startIndex++) {
                int endIndex;
                set.clear();
                if ((endIndex = startIndex + len - 1) > s.length() - 1) break;
                int p = startIndex;
                while (p <= endIndex) {
                    set.add(c[p++]);
                }
                if (set.size() == len) return len;
            }
            len--;
        }
        return 1;
    }

方法2（滑动窗口+HashSet）

思路：

• 窗口右端点不断向右扩展并向Set集合中存放元素
• 当右端点扫描到的元素在Set集合中已存在时，左端点向右移动，并且清除掉不在窗口内的元素，直到不包含该重复元素
• 始终记住：集合中每次更新存在的元素都是满足题意的无重复子串

class Solution {
    public static int lengthOfLongestSubstring(String s) {
        HashSet<Character> set = new HashSet();
        int start = 0;
        int ans = 0;
        for (int end = 0; end < s.length(); end++) {
        	// 窗口左端点收缩条件
            while (set.contains(s.charAt(end))) {
                set.remove(s.charAt(start++));
            }
            set.add(s.charAt(end));
            ans = Math.max(ans, set.size());
        }

        return ans;
    }
}

方法3（滑动窗口+HashMap）

思路：

• 定义一个map，其value用来存字符，key用来存 字符下标 + 1
• start和end为滑动窗口边界
• 随着end不断前移，在[start, end]区间一定会出现重复字符
• 此时更新start，令其为map中已存在的字符下标 + 1
• ans为滑动窗口长度最大值

对比上一种方法HashSet的区别：

• 当遇到重复元素时，上面方法的窗口左端点是一步一步往右边收缩直到不包含重复元素
• 该方法是，遇到重复元素时，直接让窗口左端点收缩到之前重复元素的右边位置

class Solution {
    public static int lengthOfLongestSubstring(String s) {
        HashMap<Character, Integer> map = new HashMap();
        int ans = 0;
        int start = 0;
        int temp;
        for (int end = 0; end < s.length(); end++) {
            // 左端点收缩条件
            if (map.containsKey(s.charAt(end))) {
                temp = start;
                start = map.get(s.charAt(end));
                // 因为端点收缩了，所以要清除掉不在窗口的元素
                while (temp < start) {
                    map.remove(s.charAt(temp++));
                }                
            }
            map.put(s.charAt(end), end + 1);
            ans = Math.max(ans, map.size());
        }
        return ans;
    }
}