题目描述

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

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

输入: s = "" 输出: 0

解题思路

本题是一道经典的滑动窗口题目。

定义两个指针 left 和 right，分别表示滑动窗口的左右边界。

将 right 向右移动，如果此时 right 指向的字符之前已经出现过(即在[left, right) 区间中已经存在该字符)，则将 left 向右移动，直到该区间中不再含有重复的字符。

过程中记录每次窗口的长度，即可得到最长无重复字符子串的长度。

代码实现

Python3 代码实现:

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:
            return 0
        left, right = 0, 1
        max_len = 1
        while right < len(s):
            if s[right] not in s[left:right]:
                right += 1
                max_len = max(max_len, right - left)
            else:
                left += 1
        return max_len

Java 代码实现:

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int left = 0, right = 1;
        int maxLen = 1;
        while (right < s.length()) {
            if (!s.substring(left, right).contains(s.charAt(right) + "")) {
                right++;
                maxLen = Math.max(maxLen, right - left);
            } else {
                left++;
            }
        }
        return maxLen;
    }
}

C++ 代码实现:

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.empty()) {
            return 0;
        }
        int left = 0, right = 1;
        int max_len = 1;
        while (right < s.size()) {
            if (s.find(s[right], left) == right) {
                right++;
                max_len = max(max_len, right - left);
            } else {
                left++;
            }
        }
        return max_len;
    }
};

时间复杂度: O(n)，其中 n 是字符串的长度。

空间复杂度: O(n)。

完整代码：

完整 Python3 代码实现:

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:
            return 0
        left, right = 0, 1
        max_len = 1
        while right < len(s):
            if s[right] not in s[left:right]:
                right += 1
                max_len = max(max_len, right - left)
            else:
                left += 1
        return max_len

完整 Java 代码实现:

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        int left = 0, right = 1;
        int maxLen = 1;
        while (right < s.length()) {
            if (!s.substring(left, right).contains(s.charAt(right) + "")) {
                right++;
                maxLen = Math.max(maxLen, right - left);
            } else {
                left++;
            }
        }
        return maxLen;
    }
}

完整 C++ 代码实现:

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.empty()) {
            return 0;
        }
        int left = 0, right = 1;
        int max_len = 1;
        while (right < s.size()) {
            if (s.find(s[right], left) == right) {
                right++;
                max_len = max(max_len, right - left);
            } else {
                left++;
            }
        }
        return max_len;
    }
};