程序员算法题每天一练0003. 无重复字符的最长子串（多种语言实现）

题目描述

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

示例 1:

"abc"

示例 2:

"b"

示例 3:

"wke"

这个函数的实现原理是使用双指针和一个哈希集合来求解最长无重复子串的长度。

首先，我们定义两个指针 i 和 j，分别表示当前子串的起始位置和结束位置。初始化时，将两个指针都指向字符串的开头。

然后，我们使用一个无序集合 ss 来存储当前遍历过的字符，保证其中没有重复字符。

接下来，我们开始遍历字符串 s。在每一次循环中，首先判断 ss 中是否已经包含当前字符 s[j]。如果是，则表示遇到了重复字符。

为了得到最长无重复子串，我们需要将起始位置 i 向右移动，并从集合 ss 中删除重复字符，直到遇到的字符不再重复为止。这个过程可以使用一个 while 循环来实现：

while (ss.count(s[j])) { ss.erase(s[i]); i++; } 

当我们处理完重复字符后，我们将当前字符 s[j] 插入集合 ss 中。这样，集合 ss 中存储的始终是当前子串中的无重复字符。

然后，我们更新最长子串的长度 ans，通过比较当前子串的长度 j - i + 1 和 ans 的大小，取其中较大的值作为新的最长子串长度。

最后，将指针 j 向右移动一位，继续遍历下一个字符。

重复上述过程，直到遍历完整个字符串 s，最终得到的 ans 就是最长无重复子串的长度。

时间复杂度分析： 该算法只需遍历一次字符串 s，所以时间复杂度为 O(n)，其中 n 是字符串的长度。同时，由于使用了一个哈希集合 ss 来存储字符，其空间复杂度也为 O(n)。

总结： 此算法通过双指针和哈希集合的方法，高效地求解了最长无重复子串的长度。

c++

#include <unordered_set>
#include <string>
#include <iostream>
using namespace std;

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_set<char> ss; // 用于存储不重复字符的集合
        int i = 0, ans = 0; // i表示当前子串的起始位置，ans表示最长子串的长度
        for (int j = 0; j < s.size(); ++j) { // 用j遍历整个字符串s
            while (ss.count(s[j])) ss.erase(s[i++]); // 当遇到重复字符时，将起始位置向右移动，并从集合中删除重复字符
            ss.insert(s[j]); // 将当前字符插入集合
            ans = max(ans, j - i + 1); // 更新最长子串的长度
        }
        return ans; // 返回最长子串的长度
    }
};

void main()
{
    Solution solution;
    string s = "abcabcbb";
    int result = solution.lengthOfLongestSubstring(s);
    cout << result << endl;

    // 输出：3
}
/*
* 模拟运行
* 01234567
* abcabcbb
 i=0 j=0  ss= a
 i=0 j=1  ss= ab
 i=0 j=2  ss= abc
 i=1 j=3  ss= bca
 i=2 j=4  ss= cab
 i=3 j=5  ss= abc
 i=5 j=6  ss= cb
 i=7 j=7  ss= b
  */

c#

public class Solution
{
    public int LengthOfLongestSubstring(string s)
    {
        var ss = new HashSet<char>(); // 用于存储不重复字符的集合
        int i = 0, ans = 0; // i表示当前子串的起始位置，ans表示最长子串的长度
        for (int j = 0; j < s.Length; ++j)
        { // 用j遍历整个字符串s
            while (ss.Contains(s[j])) ss.Remove(s[i++]); // 当遇到重复字符时，将起始位置向右移动，并从集合中删除重复字符
            ss.Add(s[j]); // 将当前字符插入集合
            ans = Math.Max(ans, j - i + 1); // 更新最长子串的长度
        }
        return ans; // 返回最长子串的长度
    }
    public static void Main()
    {
        Solution solution = new Solution();
        string s = "abcabcbb";
        int result = solution.LengthOfLongestSubstring(s);
        Console.WriteLine(result);

        // 输出：3
    }
}

Python

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        ss = set() # 用于存储不重复字符的集合
        i = ans = 0 # i表示当前子串的起始位置，ans表示最长子串的长度
        for j, c in enumerate(s): # 用j遍历整个字符串s，并使用枚举函数获取当前字符c的索引
            while c in ss: # 当遇到重复字符时
                ss.remove(s[i]) # 将起始位置向右移动，并从集合中删除重复字符
                i += 1
            ss.add(c) # 将当前字符插入集合
            ans = max(ans, j - i + 1) # 更新最长子串的长度
        return ans # 返回最长子串的长度


solution = Solution()
s = "abcabcbb"
result = solution.lengthOfLongestSubstring(s)
print(result)

# 输出：3

Java

import java.util.HashSet;
import java.util.Set;

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Set<Character> ss = new HashSet<>(); // 用于存储不重复字符的集合
        int i = 0, ans = 0; // i表示当前子串的起始位置，ans表示最长子串的长度
        for (int j = 0; j < s.length(); ++j) { // 用j遍历整个字符串s
            char c = s.charAt(j); // 获取当前字符
            while (ss.contains(c)) ss.remove(s.charAt(i++)); // 当遇到重复字符时，将起始位置向右移动，并从集合中删除重复字符
            ss.add(c); // 将当前字符插入集合
            ans = Math.max(ans, j - i + 1); // 更新最长子串的长度
        }
        return ans; // 返回最长子串的长度
    }
    
    public static void main(String[] args)
    {
    	Solution solution = new Solution();
    	String s = "abcabcbb";
    	int result = solution.lengthOfLongestSubstring(s);
    	System.out.println(result);
    }
}