【题目】
给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。
【方法】 滑动窗口
以下分析参考自leetcode。
如果依次递增地枚举子串的起始位置，那么子串的结束位置也是递增的。
这里的原因在于，假设我们选择字符串中的第 k 个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置为 rk，那么当我们选择第 k+1 个字符作为起始位置时，首先从 k+1 到 rk的字符显然是不重复的，并且由于少了原本的第 k 个字符，我们可以尝试继续增大 rk，直到右侧出现了重复字符为止。
这样一来，就可以使用「滑动窗口」来解决这个问题了。
使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的 rk。
在每一步的操作中，我们会将左指针向右移动一格，表示我们开始枚举下一个字符作为起始位置，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。
在移动结束后，这个子串就对应着 以左指针开始的，不包含重复字符的最长子串。我们记录下这个子串的长度。
在枚举结束后，我们找到的最长的子串的长度即为答案。
在上面的流程中，我们还需要使用一种数据结构来判断 是否有重复的字符，常用的数据结构为哈希集合（即 C++ 中的 std::unordered_set，Java 中的 HashSet，Python 中的 set, JavaScript 中的 Set）。在左指针向右移动的时候，我们从哈希集合中移除一个字符，在右指针向右移动的时候，我们往哈希集合中添加一个字符。
【代码实现1】
import java.util.HashSet;
import java.util.Set;
public class Solution {
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) {
// 左指针向右移动一格，移除一个字符
// 左指针移动逻辑：每次循环开始时，左指针 i 右移一位，并从集合中移除前一个位置的字符（i-1），确保窗口左边界正确收缩。
// 通过移除 i-1 位置的字符，确保窗口从新的左边界 i 开始。
// 把左指针i之前位置的字符从集合里移除，目的是更新窗口内的字符记录，s字符串都保持不变，变化的仅仅是滑动窗口的范围以及occ集合里存储的字符。
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;
}
}
【代码实现2】
class Solution {
public int lengthOfLongestSubstring(String s) {
//滑动窗口
// 将字符串转换为字符数组以提高访问效率
char[] ss = s.toCharArray();
// 使用HashSet存储窗口内的字符，确保唯一性
Set<Character> set = new HashSet<>();//去重
int res = 0;//结果
// 左右指针初始化，右指针负责扩张窗口，左指针负责收缩窗口，即外层循环扩展右边界，内层循环扩展左边界
for(int left = 0, right = 0; right < s.length(); right++) {//每一轮右端点都扩一个。
// 获取当前右指针指向的字符
char ch = ss[right];//right指向的元素，也是当前要考虑的元素
// 当窗口内已存在当前字符时，收缩窗口直到重复字符被移除
while(set.contains(ch)) {//set中有ch，则缩短左边界，同时从set集合出元素，左指针通过 while 循环快速跳到重复字符的下一个位置。
set.remove(ss[left]);
left++;
}
set.add(ss[right]);//别忘。将当前元素加入。
// 计算当前窗口长度并更新最大值
res = Math.max(res, right - left + 1);//计算当前不重复子串的长度。
}
return res;
}
}
对比上面的两个实现方案，有如下分析：
1）时间复杂度
两者均为 O (n)，但实际性能略有差异：
第一个实现（左右指针交替移动）：
外层循环：左指针 i 从 0 到 n-1，每次移动一步。
内层循环：右指针 rk 不会重置，总移动次数不超过 n 次（均摊到每个字符最多两次访问）。
关键优化：右指针 rk 的位置在每次左指针移动后保留，避免重复扫描已访问字符。
第二个实现（右指针主导，左指针被动收缩）：
外层循环：右指针 right 从 0 到 n-1，每次移动一步。
内层循环：左指针 left 被动收缩，总移动次数不超过 n 次（每个字符最多被移除一次）。
关键优化：通过 while 循环快速收缩窗口，确保窗口内无重复字符。
结论：两者时间复杂度均为 O (n)，但第二个实现在处理重复字符较多的字符串时可能更高效，因为它直接收缩到重复字符的下一个位置。
2）空间复杂度
两者均为 O (k)，其中 k 是字符集的大小（如 ASCII 为 128，Unicode 为更大值）,对于
HashSet 存储，在最坏情况下，整个字符串无重复字符，需要存储所有字符。
3）性能细节对比
字符访问方式：
第一个实现：直接通过 s.charAt(i) 访问字符。
第二个实现：先将字符串转为字符数组 ss，再通过数组索引访问。
数组访问通常比 String.charAt() 略快（减少了方法调用开销），但差异在现代 JVM 中可忽略不计。
4）窗口收缩逻辑
第一个实现：左指针每次移动一步，逐步移除元素。
第二个实现：左指针通过 while 循环快速跳到重复字符的下一个位置。
即快速收缩，在处理长重复子串时更高效，例如字符串 "aaaaa"，第一个实现需 O (n²) 次移除操作，而第二个实现仅需 O (n)。
5）循环控制
第一个实现：右指针 rk 初始化为 -1，循环条件为 rk + 1 < n。
第二个实现：右指针 right 初始化为 0，循环条件为 right < n。
两者逻辑等价，但第二个实现的循环条件更直观。
6）代码简洁性与可读性
第二个实现 更简洁：
使用 left 和 right 作为指针变量，命名更直观。
通过 right - left + 1 直接计算窗口长度，无需额外变量。
收缩逻辑更清晰，通过 while 循环确保窗口合法性。
推荐选择：第二个实现。其代码更简洁，收缩逻辑更高效，尤其适合处理包含大量重复字符的输入。
上面的代码实现是通过JAVA语言，也可以通过C++语言实现。
class Solution {
public:
int lengthOfLongestSubstring(string s) {
// 哈希集合，记录每个字符是否出现过
unordered_set<char> occ;
int n = s.size();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
// 枚举左指针的位置，初始值隐性地表示为 -1
for (int i = 0; i < n; ++i) {
if (i != 0) {
// 左指针向右移动一格，移除一个字符
occ.erase(s[i - 1]);
}
while (rk + 1 < n && !occ.count(s[rk + 1])) {
// 不断地移动右指针
occ.insert(s[rk + 1]);
++rk;
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, rk - i + 1);
}
return ans;
}
};
