[力扣]无重复字符的最长子串：给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度[leetcode 003]

3.最长无重复子串：从问题分析到高效算法实现

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

问题描述

在字符串处理的世界里，我们经常会遇到这样一类经典问题：如何从一段文字中找出不含重复字符的最长连续片段？这就是我们今天要聚焦的“最长无重复子串”问题。无论是分析用户输入的关键词、处理日志数据，还是优化文本检索算法，这个问题都有着广泛的实际应用场景。

要真正理解这个问题，首先需要明确一个关键概念：子串与子序列的区别。很多人初学时容易混淆这两个概念，我们通过一个具体例子来区分：
以字符串 “pwwkew” 为例，“wke” 是其中的子串——它由连续的字符组成（对应原字符串中从索引 2 到 4 的位置）；而 “pwke” 则是子序列——它的字符在原字符串中顺序一致，但中间可以间隔其他字符（比如跳过了第二个 ‘w’）。最长无重复子串问题中，我们只关注连续的字符片段，这一点至关重要。

核心区别总结：

• 子串：字符必须连续出现，如 “pwwkew” 中的 “wke”（位置 2-4）
• 子序列：字符顺序一致但可不连续，如 “pwwkew” 中的 “pwke”（跳过第二个 ‘w’）

接下来，我们通过三个典型示例进一步理解问题的输入输出逻辑：

示例 1：输入 “abcabcbb”
输出结果为 3。
原因分析：字符串中不含重复字符的子串有 “abc”（位置 0-2）、“bca”（位置 1-3）、“cab”（位置 2-4）等，其中最长的连续片段长度为 3。

示例 2：输入 “bbbbb”
输出结果为 1。
原因分析：由于所有字符均为 ‘b’，任意连续子串都包含重复字符，因此最长无重复子串只能是单个 ‘b’，长度为 1。

示例 3：输入 “pwwkew”
输出结果为 3。
原因分析：可能的无重复子串包括 “wke”（位置 2-4）和 “kew”（位置 3-5），两者长度均为 3，因此最长长度为 3。注意这里不能选择 “pwke”，因为它是子序列而非连续子串。

了解问题的边界条件同样重要，这能帮助我们设计更鲁棒的算法：

题目约束条件：

• 字符串长度范围：0 ≤ s.length ≤ 5 * 10⁴（即最长可达 5 万个字符，需考虑算法效率）
• 字符类型：包含英文字母（大小写敏感，如 ‘A’ 与 ‘a’ 视为不同字符）、数字（0-9）、符号（如 !、@、# 等）及空格

通过明确问题定义、关键概念区分、示例分析和边界条件，我们已经为后续的算法设计打下了坚实基础。接下来，我们将深入探讨如何高效求解这个问题。

解题思路

面对“最长无重复子串”这个经典问题，我们该从何入手呢？不妨先从最直观的思路开始探索，再逐步优化，感受算法设计的演变过程。

从暴力法开始：直观但低效的尝试

最直接的想法是枚举所有可能的子串，再判断每个子串是否包含重复字符。具体来说，我们可以用两层嵌套循环确定子串的起始和结束位置（时间复杂度O(n²)），然后对每个子串检查是否有重复字符（时间复杂度O(n)）。这种方法的总时间复杂度达到O(n³)——当字符串长度n为1000时，就需要近10亿次运算，显然无法应对大数据量的场景。

暴力法的核心问题：大量重复计算。例如在字符串"abcabcbb"中，我们会反复检查"abc"、"bca"等相似子串，却没有利用之前的计算结果。

滑动窗口法：用“动态窗口”减少重复计算

既然暴力法的问题在于重复检查，那能否用一个“动态窗口”来跟踪当前的无重复子串呢？这就是滑动窗口法的核心思想：

• 窗口的定义：用两个指针（左指针left、右指针right）划定当前无重复子串的范围[left, right]，窗口内的字符均不重复。
• 右指针的作用：不断向右移动扩展窗口，探索新的字符。
• 左指针的作用：当右指针遇到重复字符时，左指针向右收缩窗口，直到窗口内不再有重复字符。

比如处理"abcabcbb"时：

1. 初始left=0，right=0，窗口为"a"；
2. right依次移动到1（“ab”）、2（“abc”），窗口持续扩大；
3. right=3时遇到字符"a"（已在窗口中），left移动到1，窗口变为"bca"；
4. 后续重复此过程，最终找到最长窗口"abc"（长度3）。

滑动窗口法将时间复杂度降至O(n)（每个字符最多被左右指针各访问一次），但基础实现中用集合存储窗口字符时，左指针需要逐个移动（例如从left=0移到left=1），仍有优化空间。

字典优化：让左指针“跳跃”而非“爬行”

为进一步提升效率，我们可以用字典（哈希表）存储字符的最新位置。当右指针遇到重复字符c时，直接将左指针跳转到max(left, 字典[c]+1)，避免逐个移动的低效操作。

例如在"abba"中：

• right=0（“a”），字典记录{“a”:0}；
• right=1（“b”），字典记录{“a”:0, “b”:1}；
• right=2（“b”），此时重复字符"b"的位置是1，left跳转到max(0,1+1)=2，窗口变为"ba"；
• right=3（“a”），重复字符"a"的位置是0，left跳转到max(2,0+1)=2，窗口变为"ba"（长度2）。

通过字典优化，滑动窗口法的实际运行效率大幅提升，尤其在重复字符较多的场景下表现更优。

优化关键：字典不仅存储字符是否存在，更记录其最新位置，让左指针实现“跳跃式”移动，这是从“基础解法”到“高效解法”的关键突破。

从暴力枚举到滑动窗口，再到字典优化，我们能清晰看到算法设计中“发现冗余→针对性优化”的思考路径——这正是解决复杂问题的核心思维方式。

算法实现

滑动窗口算法是解决最长无重复子串问题的高效方案，其核心思想是通过左右指针维护一个动态窗口，不断调整窗口范围以确保无重复字符。下面我们分基础版和优化版两种实现方式，带你逐步理解算法的演进过程。

基础版：集合辅助的滑动窗口

基础版实现使用集合（Set） 作为辅助数据结构，利用集合的快速查找特性判断字符是否重复。整体遵循"初始化→遍历→更新窗口→记录最大长度"的标准流程：

def length_of_longest_substring(s: str) -> int:
    char_set = set()  # 存储当前窗口内的字符，用于O(1)时间判断重复
    left = 0  # 左指针，窗口左边界
    max_len = 0  # 记录最长无重复子串长度
    
    for right in range(len(s)):  # 右指针遍历字符串，扩展窗口右边界
        # 若当前字符已在集合中（窗口内存在重复），收缩左指针直至无重复
        while s[right] in char_set:
            char_set.remove(s[left])  # 移除左指针指向的字符
            left += 1  # 左指针右移
        char_set.add(s[right])  # 将当前字符加入集合，更新窗口
        # 计算当前窗口长度（right - left + 1），更新最大长度
        max_len = max(max_len, right - left + 1)
    
    return max_len

基础版核心逻辑：右指针负责"探索新字符"，左指针负责"清理重复字符"。当遇到重复时，左指针需逐个右移并移除集合中对应的字符，直到窗口内不再包含重复字符。这种方式的时间复杂度为O(n²)（最坏情况下左指针需遍历整个字符串），适用于理解滑动窗口的基本原理。

优化版：字典优化的指针跳转

优化版通过字典（Dictionary） 记录字符的最新索引，将左指针的"逐个移动"优化为"直接跳转"，大幅提升效率。核心改进在于利用字典存储字符与索引的映射关系，避免左指针的冗余移动：

def length_of_longest_substring(s: str) -> int:
    char_index = {}  # 键：字符，值：字符最后出现的索引
    left = 0  # 左指针，窗口左边界
    max_len = 0  # 记录最长无重复子串长度
    
    for right in range(len(s)):  # 右指针遍历字符串
        current_char = s[right]
        # 若字符已存在且索引在当前窗口内（>= left），则左指针跳转到重复字符的下一位
        if current_char in char_index and char_index[current_char] >= left:
            # 左指针取max避免回退：确保左指针始终向右移动（处理重复字符在窗口外的情况）
            left = max(left, char_index[current_char] + 1)
        char_index[current_char] = right  # 更新字符的最新索引
        # 计算当前窗口长度并更新最大长度
        max_len = max(max_len, right - left + 1)
    
    return max_len

优化版关键改进：字典char_index存储每个字符最后出现的位置，当遇到重复字符时，左指针直接跳转到"重复字符索引+1"的位置，无需逐个移动。通过max(left, ...)确保左指针不会回退到之前的位置（例如处理"abba"这类字符串时，避免左指针从2退回到1）。优化后时间复杂度降至O(n)，空间复杂度为O(min(m, n))（m为字符集大小）。

两版实现对比与总结

无论是基础版还是优化版，均遵循滑动窗口的核心框架：初始化指针与辅助结构→右指针遍历扩展窗口→根据重复情况更新左指针→记录最大窗口长度。两者的关键差异在于窗口收缩策略：

实现方式	辅助结构	左指针移动方式	时间复杂度	适用场景
基础版	集合	逐个移动	O(n²)	原理理解
优化版	字典	直接跳转	O(n)	实际应用

通过对比可以清晰看到，优化版利用字典的索引记录功能，将左指针的线性收缩优化为常数级跳转，这是算法效率提升的核心所在。在实际开发中，推荐使用字典优化版，既能保证高效性，又能处理各类边界情况（如重复字符在窗口外、连续重复字符等）。

复杂度分析

在算法设计中，复杂度分析就像给代码做“体检报告”，能直观反映算法的效率表现。滑动窗口算法之所以能成为解决“最长无重复子串”问题的优选方案，其出色的时间和空间复杂度是关键所在。

时间复杂度：线性扫描的高效性

滑动窗口算法的时间复杂度可以用“一次遍历”来概括。想象两个指针在字符串上协同移动：右指针从字符串起点滑到终点，每个字符仅被访问一次；左指针则始终跟随右指针同向移动，绝不会回退。这种“不回头”的特性确保了每个字符最多被左右指针各访问一次，整体操作次数与字符串长度n呈线性关系，因此时间复杂度为 O(n)。

举个直观的例子：处理长度为1000的字符串时，滑动窗口只需约2000次操作（左右指针合计）；而随着字符串长度增长，操作次数也只是成比例增加，不会出现指数级暴涨。

空间复杂度：字符集大小的边界约束

空间复杂度主要取决于存储字符位置的哈希表（或数组）。这个数据结构的大小由字符串中可能出现的字符种类数量m决定——比如标准ASCII字符集有128种字符，扩展ASCII有256种，而Unicode字符集则可能包含更多。由于窗口内不会出现重复字符，哈希表存储的字符数量最多不会超过min(m, n)（m为字符集大小，n为字符串长度）。因此，空间复杂度为 O(min(m, n))。

实际应用中的空间表现：当处理英文字符串（ASCII字符集）时，哈希表最多占用128个存储单元，空间消耗几乎恒定；即使面对包含数万字符的长文本，只要字符种类有限，空间复杂度也能保持在较低水平。

与暴力法的对比：效率的天壤之别

暴力法通过枚举所有子串（O(n²)种可能）并逐个检查重复（O(n)时间），整体复杂度高达 O(n³)。这种效率差距在数据量增大时会变得极其显著：

• 当字符串长度n=5×10⁴时，暴力法需要执行(5×10⁴)³ = 1.25×10¹⁴次操作，这在普通计算机上可能需要数小时甚至 days 才能完成；
• 而滑动窗口算法仅需5×10⁴次操作，毫秒级即可得出结果。

这种“线性vs立方”的效率差异，正是滑动窗口算法在处理大规模数据时的核心优势。

示例解析

为帮助直观理解滑动窗口算法的执行逻辑，我们通过三个典型案例进行步骤拆解，详细记录每次指针移动、字典状态变化及窗口调整过程，揭示无重复子串查找的核心机制。

“abcabcbb”：多重复字符的窗口动态调整

该字符串包含多组重复字符（a、b、c各出现2-3次），适合观察窗口如何通过左右指针协作实现动态收缩与扩展。以下是右指针从0到7的完整移动过程：

步骤	右指针	当前字符	字典状态（字符:索引）	左指针	窗口长度	最大长度	关键操作说明
1	0	‘a’	{} → {‘a’:0}	0	1	1	首次出现，字典记录索引，窗口[0,0]
2	1	‘b’	{‘a’:0} → {‘a’:0,‘b’:1}	0	2	2	无重复，窗口扩展为[0,1]
3	2	‘c’	{‘a’:0,‘b’:1} → {‘a’:0,‘b’:1,‘c’:2}	0	3	3	无重复，窗口扩展为[0,2]
4	3	‘a’	'a’已存在（索引0 ≥ 左指针0）	0→1	3	3	左指针跳转至重复字符索引+1（0+1=1），字典更新{‘a’:3}，窗口[1,3]
5	4	‘b’	'b’已存在（索引1 ≥ 左指针1）	1→2	3	3	左指针跳转至1+1=2，字典更新{‘b’:4}，窗口[2,4]
6	5	‘c’	'c’已存在（索引2 ≥ 左指针2）	2→3	3	3	左指针跳转至2+1=3，字典更新{‘c’:5}，窗口[3,5]
7	6	‘b’	'b’已存在（索引4 ≥ 左指针3）	3→5	2	3	左指针跳转至4+1=5，字典更新{‘b’:6}，窗口[5,6]
8	7	‘b’	'b’已存在（索引6 ≥ 左指针5）	5→7	1	3	左指针跳转至6+1=7，字典更新{‘b’:7}，窗口[7,7]

核心规律：当遇到重复字符且其上次索引在当前窗口内（≥左指针）时，左指针必须"跳跃式"移动至重复索引+1，而非逐步右移，这是算法实现O(n)时间复杂度的关键。

“bbbbb”：全重复字符的极端场景

该字符串所有字符均为’b’，可直观展示重复字符对窗口大小的限制作用。右指针从0到4的过程中：

• 右指针=0：字符’b’首次出现，字典记录{‘b’:0}，左指针=0，窗口[0,0]，长度1，最大1；
• 右指针=1：字符’b’已存在（索引0 ≥ 左指针0），左指针跳转至0+1=1，字典更新{‘b’:1}，窗口[1,1]，长度1，最大不变；
• 右指针=2-4：重复上述逻辑，左指针始终等于右指针，窗口长度恒为1，最大长度保持1。

关键结论：当所有字符均重复时，窗口无法扩展，左指针与右指针同步移动，最终最长无重复子串长度为1。

“pwwkew”：左指针跳跃与窗口二次扩展

该案例包含"ww"连续重复字符及后续非重复序列，重点观察左指针如何通过一次跳跃实现窗口重置，以及重置后如何重新扩展。右指针移动过程如下：

1. 右指针=0（‘p’）：字典空→{‘p’:0}，左0，窗口[0,0]，长度1，最大1；
2. 右指针=1（‘w’）：字典无→{‘p’:0,‘w’:1}，左0，窗口[0,1]，长度2，最大2；
3. 右指针=2（‘w’）：'w’已存在（索引1 ≥ 左指针0），左指针跳转至1+1=2，字典更新{‘w’:2}，窗口[2,2]，长度1，最大仍为2；
4. 右指针=3（‘k’）：字典无→{‘p’:0,‘w’:2,‘k’:3}，左2，窗口[2,3]，长度2，最大2；
5. 右指针=4（‘e’）：字典无→{‘p’:0,‘w’:2,‘k’:3,‘e’:4}，左2，窗口[2,4]，长度3，最大3；
6. 右指针=5（‘w’）：'w’存在（索引2 = 左指针2），左指针跳转至2+1=3，字典更新{‘w’:5}，窗口[3,5]，长度3，最大仍为3。

最终最长无重复子串为"wke"（索引2-4），长度3。此案例展示了窗口在经历收缩后可重新扩展的特性——左指针跳跃后，新窗口从跳转位置开始重新累积非重复字符。

边界情况处理

在解决最长无重复子串问题时，边界情况的处理往往决定了算法的健壮性。这些特殊输入场景看似简单，却可能隐藏着逻辑漏洞，尤其是在滑动窗口等复杂算法实现中。下面我们分类讨论三类典型边界情况，通过场景描述、预期输出和代码逻辑拆解，帮助你全面掌握特殊输入的处理技巧。

空字符串：快速返回基线值

场景描述：当输入字符串为空（s = ""）时，由于不存在任何字符，自然不存在子串。
预期输出：0
处理逻辑：在算法执行初期直接添加判断条件，避免后续无效计算。

def length_of_longest_substring(s: str) -> int:
    if not s:  # 处理空字符串边界情况
        return 0
    # 后续算法逻辑...

这种“提前拦截”的处理方式能显著提升性能，尤其在高频调用场景下可减少不必要的内存分配和循环执行。

单字符字符串：窗口自然收敛

场景描述：当输入字符串仅包含一个字符（如s = "a"或s = "5"）时，由于不存在重复字符，最长子串就是其本身。
预期输出：1
处理逻辑：无需额外特殊处理，滑动窗口机制会自然覆盖该场景。初始化时left = 0，right从0开始遍历，哈希表记录字符位置后，max_length会直接更新为right - left + 1 = 1。
关键观察：单字符场景验证了滑动窗口初始化的合理性——当窗口大小为1时，左右指针重合，无需调整即可得到正确结果。

"abba"案例：左指针防回退机制

场景描述：输入字符串为"abba"时，常规滑动窗口逻辑可能出现左指针回退的问题。例如当right移动到索引3（字符'a'）时，若直接将left设为last_occurrence['a'] + 1 = 0 + 1 = 1，会导致左指针从2回退到1，窗口范围错误扩大。
预期输出：2（正确子串为"ab"或"ba"）
处理逻辑：通过max(left, last_occurrence[char] + 1)确保左指针只向右移动，避免回退到已处理的位置。

last_occurrence = {}
left = 0
max_length = 0
for right, char in enumerate(s):
    if char in last_occurrence:
        # 关键：使用max避免左指针回退
        left = max(left, last_occurrence[char] + 1)
    last_occurrence[char] = right
    current_length = right - left + 1
    if current_length > max_length:
        max_length = current_length
return max_length

以"abba"为例，遍历过程如下：

• right=0（‘a’）：last_occurrence['a']=0，max_length=1
• right=1（‘b’）：last_occurrence['b']=1，max_length=2
• right=2（‘b’）：last_occurrence['b']=1，left = max(0, 1+1)=2，current_length=1
• right=3（‘a’）：last_occurrence['a']=0，left = max(2, 0+1)=2，current_length=2，max_length保持2

防回退原理：max(left, ...)确保左指针始终基于当前窗口的左边界向右调整，避免因历史记录导致的窗口范围异常。这是处理重复字符在窗口内外交替出现的核心技巧。

通过上述三类边界情况的分析，我们可以总结出滑动窗口算法的鲁棒性设计要点：初始判断过滤极端输入、利用算法天然特性处理简单场景、关键逻辑添加防护机制避免回退。这些处理不仅能覆盖99%的特殊输入，更能帮助我们深入理解算法的内在逻辑。在实际编码中，建议先写出核心逻辑，再针对这些边界情况进行针对性测试和优化。