滑动窗口算法解决最长无重复子串问题

单单必成

1. 题目解析与解题思路

这道题目要求我们从一个字符串中找出最长的不包含重复字符的子字符串，并返回其长度。这是一个经典的字符串处理问题，在算法面试中经常出现。我们先来看几个示例：

输入"abcabcbb"，最长无重复子串是"abc"，长度为3
输入"bbbbb"，最长无重复子串是"b"，长度为1
输入"pwwkew"，最长无重复子串是"wke"，长度为3

1.1 问题本质分析

这个问题本质上是在寻找字符串中满足特定条件（无重复字符）的最长子串。这类子串问题通常可以考虑以下几种解法：

暴力枚举法：检查所有可能的子串
滑动窗口法：动态维护一个满足条件的窗口
优化滑动窗口：利用哈希表记录字符位置

1.2 暴力解法分析

最直观的解法是暴力枚举所有可能的子串，然后检查每个子串是否包含重复字符。具体实现如下：

java复制public int lengthOfLongestSubstring(String s) {
    if (s == null || s.length() == 0) return 0;
    
    int n = s.length();
    int maxLen = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isUnique(s, i, j)) {
                maxLen = Math.max(maxLen, j - i + 1);
            } else {
                break;
            }
        }
    }
    return maxLen;
}

private boolean isUnique(String s, int left, int right) {
    Set<Character> set = new HashSet<>();
    for (int i = left; i <= right; i++) {
        char c = s.charAt(i);
        if (set.contains(c)) return false;
        set.add(c);
    }
    return true;
}

这种方法的时间复杂度是O(n³)，对于较长的字符串效率很低，在实际应用中不推荐使用。

2. 滑动窗口解法详解

2.1 基本滑动窗口思路

滑动窗口是一种更高效的解法，它通过维护一个窗口来动态调整子串范围。基本思路是：

使用两个指针left和right表示窗口的左右边界
使用一个集合记录当前窗口中的字符
右指针不断向右移动扩展窗口
当遇到重复字符时，左指针向右移动收缩窗口

java复制public int lengthOfLongestSubstring(String s) {
    Set<Character> window = new HashSet<>();
    int left = 0, right = 0;
    int maxLen = 0;
    
    while (right < s.length()) {
        char c = s.charAt(right);
        if (!window.contains(c)) {
            window.add(c);
            right++;
            maxLen = Math.max(maxLen, right - left);
        } else {
            window.remove(s.charAt(left));
            left++;
        }
    }
    return maxLen;
}

这种解法的时间复杂度是O(2n)=O(n)，因为每个字符最多被访问两次（被left和right各访问一次）。

2.2 滑动窗口优化思路

基本滑动窗口解法在遇到重复字符时，左指针只能一步一步向右移动，效率可以进一步优化。我们可以记录每个字符最后出现的位置，当遇到重复字符时，直接将左指针跳到重复字符的下一个位置。

java复制public int lengthOfLongestSubstring(String s) {
    Map<Character, Integer> charIndex = new HashMap<>();
    int left = 0, maxLen = 0;
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (charIndex.containsKey(c) && charIndex.get(c) >= left) {
            left = charIndex.get(c) + 1;
        }
        charIndex.put(c, right);
        maxLen = Math.max(maxLen, right - left + 1);
    }
    return maxLen;
}

这种优化将时间复杂度降低到严格的O(n)，因为每个字符只被访问一次。

3. 最优解法实现与性能分析

3.1 使用固定数组优化

考虑到ASCII字符只有128个，我们可以使用固定大小的数组代替哈希表，进一步优化空间效率。

java复制public int lengthOfLongestSubstring(String s) {
    int[] lastIndex = new int[128];
    Arrays.fill(lastIndex, -1);
    int left = 0, maxLen = 0;
    
    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (lastIndex[c] >= left) {
            left = lastIndex[c] + 1;
        }
        lastIndex[c] = right;
        maxLen = Math.max(maxLen, right - left + 1);
    }
    return maxLen;
}

这种实现的空间复杂度是O(1)（固定128大小的数组），时间复杂度仍然是O(n)，是最优的解法。

3.2 复杂度对比

解法类型	时间复杂度	空间复杂度	适用场景
暴力解法	O(n³)	O(min(n,128))	不推荐使用
基本滑动窗口	O(2n)	O(min(n,128))	通用解法
优化滑动窗口	O(n)	O(min(n,128))	推荐解法
数组优化	O(n)	O(1)	最优解法

4. 边界条件与测试用例

4.1 常见边界情况

空字符串：应返回0
全相同字符：如"bbbbb"应返回1
无重复字符：如"abcdef"应返回字符串长度
重复出现在不同位置：如"abba"需要正确处理

4.2 测试用例设计

java复制@Test
public void testSolution() {
    Solution solution = new Solution();
    
    assertEquals(0, solution.lengthOfLongestSubstring(""));
    assertEquals(1, solution.lengthOfLongestSubstring("b"));
    assertEquals(3, solution.lengthOfLongestSubstring("abcabcbb"));
    assertEquals(1, solution.lengthOfLongestSubstring("bbbbb"));
    assertEquals(3, solution.lengthOfLongestSubstring("pwwkew"));
    assertEquals(4, solution.lengthOfLongestSubstring("abcd"));
    assertEquals(3, solution.lengthOfLongestSubstring("abba"));
    assertEquals(5, solution.lengthOfLongestSubstring("tmmzuxt"));
}