3.力扣——无重复字符的最长子串（总结）

一个力扣的题目：

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

示例 1:

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

示例 2:

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

示例 3:

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

提示：

• 0 <= s.length <= 5 * 104
• s 由英文字母、数字、符号和空格组成

题解如下：

方法：滑动窗口

以字符串s = "abacda"为例，找出从每一个字符开始的，不包含重复字符的最长子串，那么其中最长的那个字符串即为答案。使用两个指针表示字符串中的某个子串（或窗口）的左右边界。使用一种数据结构来判断是否为重复的。常用的数据结构为哈希集合（即 C++ 中的 std::unordered_set，Java 中的 HashSet，Python 中的 set, JavaScript 中的 Set）。

代码1：抽象版

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 定义一个数组idx，用于记录字符在字符串中的最后出现位置
        int idx[128] = {0}; //ASCII是128个，所以是128.
        // 初始化左指针left，用于记录当前不含重复字符的子串的起始位置
        int left = 0; 
        // 初始化变量len，用于记录当前不含重复字符的子串的最大长度
        int len = 0; 
        
        // 遍历字符串s中的每个字符
        for (int i = 0; i < s.size(); i++) {
            // 更新左指针left的位置为当前字符s[i]上次出现位置的下一个位置和left中较大的那个
            left = max(left, idx[s[i]]);
            
            // 更新len的值为当前子串的长度和len中较大的那个
            len = max(len, i - left + 1);
            // 更新数组idx中字符s[i]的值为当前字符s[i]的位置加1
            // 由于数组下标从0开始，为了与字符串下标保持一致，将位置加1保存
            idx[s[i]] = i + 1;//这一行有点抽象，给我看不会了
        }
        // 返回不含重复字符的最长子串的长度
        return len;
    }
};

看不懂看这个例子：以字符串abacda为例子。

开始遍历字符串s = "abacda"的每个字符：

• 当i = 0时，当前字符s[0]是'a'，在idx数组中idx['a']为0（因为初始时所有位置都是0），所以更新left的值为0（max(0, 0)），更新len的值为1（i - left + 1 = 0 - 0 + 1 = 1），并更新idx['a']为1。（idx['a']其实a转换为ASCII码值了，其实还是哈希的思想）

• 当i = 1时，当前字符s[1]是'b'，在idx数组中idx['b']为0，所以更新left的值为0（max(0, 0)）因为是数组，0代表这字串是从第一个a开始的，更新len的值为2（i - left + 1 = 1 - 0 + 1 = 2），并更新idx['b']为2。

• 当i = 2时，当前字符s[2]是'a'，在idx数组中idx['a']为1，因为'a'上次出现的位置是1（字符串的索引是从0开始的），所以更新left的值为1（max(0, 1)）1表示从第二个位置b，更新len的值为2（i - left + 1 = 2 - 1 + 1 = 2），并更新idx['a']为3（其实一直在记录一个字符最近出现的位置）。

• 当i = 3时，当前字符s[3]是'c'，在idx数组中idx['c']为0，所以更新left的值为1（max(1, 0)），更新len的值为3（i - left + 1 = 3 - 1 + 1 = 3），并更新idx['c']为4。

• 当i = 4时，当前字符s[4]是'd'，在idx数组中idx['d']为0，所以更新left的值为1（max(1, 0)），更新len的值为4（i - left + 1 = 4 - 1 + 1 = 4），并更新idx['d']为5。

• 当i = 5时，当前字符s[5]是'a'，在idx数组中idx['a']为3，所以更新left的值为3（max(1, 3)），更新len的值为3（i - left + 1 = 5 - 3 + 1 = 3），并更新idx['a']为6。

• 遍历完整个字符串后，最终返回的len值为4，即不含重复字符的最长子串的长度为4，对应的子串是"bacd"。

反正挺神奇，这样一种很朴素高明的解法展示了滑动窗口的思想，当你n个字符内没有重复的，而第n+1个和第1个重复了，其实一个窗口往前走一个仍然是n个字符内没有重复的，一直往前走，保存最大的就好了。

虽然这个很神奇，我感觉似懂非懂的。

本人用python写的和这个挺像，但是好懂一点：因为我的左指针left如果有重复字符是直接加1的，当前该重复字符的最新出现位置为右指针，上面的c++有点绕，但是看了两遍，我居然写的和它一样，笔记白写了。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        n = len(s)  # 获取字符串的长度
        max_length = 0  # 用于记录最长不含重复字符的子串长度
        left = 0  # 记录当前不含重复字符的子串的起始位置
        char_index = {}  # 字典，用于记录每个字符最后出现的位置

        # 遍历字符串 s 中的每个字符
        for right in range(n):
            # 如果当前字符已经在 char_index 中存在，并且其最后出现的位置大于等于 left，
            # 说明当前字符重复了，需要更新 left 的位置为上次该字符出现的下一个位置
            if s[right] in char_index and char_index[s[right]] >= left:
                left = char_index[s[right]] + 1

            # 将当前字符的最后出现位置更新为 right
            char_index[s[right]] = right

            # 计算当前不含重复字符的子串的长度，并更新 max_length
            max_length = max(max_length, right - left + 1)

        # 返回最长不含重复字符的子串的长度
        return max_length

代码2：使用set版

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 获取字符串s的长度
        int len = s.size();
        // 初始化结果变量为0，用于记录最长子串的长度
        int res = 0;
        // 初始化右指针r为0，用于记录当前不含重复字符的子串的结束位置
        int r = 0;
        // 使用无序集合unordered_set来存储当前窗口中出现过的字符，用于判断字符是否重复
        unordered_set<char> st;
        // 遍历字符串s中的每个字符
        for (int i = 0; i < len; i++) {
            // 移动右指针r，直到出现重复字符或者到达字符串末尾
            while (r < len && !st.count(s[r])) {//count计数，当重复就为1，取反为0就会跳出
                // 将字符s[r]插入到集合st中
                st.insert(s[r]);
                // 右指针r向右移动一位
                r++;
            }
            
            // 更新最长子串的长度为当前子串的长度和res中较大的那个
            res = max(res, r - i);
            
            // 将字符s[i]从集合st中删除，以维持窗口内的字符都是不重复的
            st.erase(s[i]);
        }
        
        // 返回最长子串的长度
        return res;
    }
};

比上个代码好理解不少，不解释了，两个指针移来移去，但是依旧有点难写，使用了set，其实还好，当然还有代码3。

代码3：朴素版

const int N = 5e4 + 10;  // 定义常量N，题目要求，虽然这么大没必要吧可能
class Solution {
    int a[N];  // 用来记录每个字符出现的个数
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0;  // 初始化结果变量为0，用于记录最长子串的长度
        for (int i = 0, j = 0; i < s.size(); i++) {  // 使用双指针i和j遍历字符串s，i是一直往右走的，j是记录起点的。
            a[s[i]]++;  // 记录字符s[i]出现的个数，还是哈希思想，s[i]是键。
            while (a[s[i]] > 1) {  // 当字符s[i]出现的个数大于1时，说明有重复字符
                a[s[j]]--;  // 将字符s[j]出现的个数减1
                j++;  // 左指针j向右移动
            }
            res = max(res, i - j + 1);  // 更新最长子串的长度为当前子串的长度和res中较大的那个
        }
        return res;  // 返回最长子串的长度
    }
};

这个已经是最简单的了吧。

代码4：又快内存又少map版

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        // 哈希表记录字符最后出现的位置
        unordered_map<char, int> hash;   
        int ans = 0;  // 记录最长子串的长度
        int left = 0; // 记录当前不含重复字符的子串的起始位置
        int i;  // 循环变量
        
        // 遍历字符串s的每个字符
        for (i = 0; i < s.length(); ++i) {
            char cur = s[i];  // 获取当前字符
            
            // 如果当前字符已经在哈希表中出现过
            if (hash.count(cur)) {
                // 更新最长子串的长度为当前子串的长度和ans中较大的那个
                ans = max(ans, i - left);
                // 更新left的值为当前字符上次出现位置的下一个位置和left中较大的那个
                left = max(left, hash[cur] + 1);
            }
            // 更新哈希表中字符cur的值为当前位置i
            hash[cur] = i;
        }
        
        // 返回最长子串的长度
        return max(ans, i - left);
    }
};

其实和set那个没啥区别，但是就是快，指针不是一个个移动了，右指针传送，所以快点。
 

总结：

总之，这几个代码思想都一样，但是写法不一样，故记录一下。

题目来源：. - 力扣（LeetCode）