leetcode hot100 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 * 10^4
• s 由英文字母、数字、符号和空格组成

我的思路

1. 特殊情况：字符串为空，返回0，字符串长度为1，返回1
2. 设置左右指针，初始位置为索引0和索引1，子串最大长度值初始为0
3. 创建字典，存放子串中已有字符
4. 将左指针对应字符放入字典
5. 在左右指针索引值小于字符串长度n时，进入循环
   1. 判断右指针对应字符在字典中是否存在
      1. 不存在，将字符加入字典，右指针右移一位，进入下一轮循环
      2. 存在：
         1. 更新最大长度值
         2. 删除字典中左指针所指字符，并将左指针右移，至左右指针所指元素相同
         3. 此时左指针的下一个元素即为新子串的开端，所以将左指针再右移一位
         4. 右指针所指元素已经在字典中，所以也直接右移一位
         5. 进入下一轮循环
6. 最后返回最大长度值

代码

java

package q3_length_of_longest_substring;

import java.util.HashMap;

public class LengthOfLongestSubstring {
    public int lengthOfLongestSubstring(String s) {
//        特殊情况：字符串为空，返回0，字符串长度为1，返回1
        if(s == null || s.length() == 0) return 0;
        if(s.length() == 1) return 1;
//      设置左右指针，初始位置为索引0和索引1，子串最大长度值初始为0
        char[] arr=s.toCharArray();
        int left=0;
        int right=1;
        int max=0;
//        创建字典，存放子串中已有字符
        HashMap map=new HashMap();
//        将左指针对应字符放入字典
        map.put(arr[left],1);
//        在左右指针索引值小于字符串长度n时，进入循环
        while(right<arr.length && left<arr.length){
//            判断右指针对应字符在字典中是否存在
            if(map.containsKey(arr[right])){
//                更新最大长度值
                max=max>(right-left)?max:(right-left);
//                删除字典中左指针所指字符，并将左指针右移，至左右指针所指元素相同
                while(arr[left]!=arr[right]){
                    map.remove(arr[left],1);
                    left++;
                }
//                此时左指针的下一个元素即为新子串的开端，所以将左指针再右移一位
                left++;
//                右指针所指元素已经在字典中，所以也直接右移一位
                right++;
            }else{
//                不存在，将字符加入字典，右指针右移一位，进入下一轮循环
                map.put(arr[right],1);
                right++;
            }
        }
        max=max>(right-left)?max:(right-left);
        return max;
    }

    public static void main(String[] args) {
        String s="au";
        LengthOfLongestSubstring longestSubstring=new LengthOfLongestSubstring();
        System.out.println(longestSubstring.lengthOfLongestSubstring(s));
    }
}

Python

class LengthOfLongestSubstring:
    def lengthOfLongestSubstring(self,s):
        # 特殊情况：字符串为空，返回0，字符串长度为1，返回1
        if len(s)==0 :return 0
        if len(s)==1 :return 1
        # 设置左右指针，初始位置为索引0和索引1，子串最大长度值初始为0
        left,right,max=0,1,0
        # 创建字典，存放子串中已有字符
        string_dict={}
        # 将左指针对应字符放入字典
        string_dict[s[left]]=1
        # 在左右指针索引值小于字符串长度n时，进入循环
        while right<len(s) and left<len(s):
            # 判断右指针对应字符在字典中是否存在
            if s[right] in string_dict:
                # 更新最大长度值
                max = max if max>(right-left) else (right-left)
                # 删除字典中左指针所指字符，并将左指针右移，至左右指针所指元素相同
                while s[left]!=s[right]:
                    string_dict.pop(s[left])
                    left+=1
                # 此时左指针的下一个元素即为新子串的开端，所以将左指针再右移一位
                left+=1
                # 右指针所指元素已经在字典中，所以也直接右移一位
                right+=1
            else:
                # 不存在，将字符加入字典，右指针右移一位，进入下一轮循环
                string_dict[s[right]]=1
                right+=1
        max = max if max > (right - left) else (right - left)
        return max

s1="abcabcbb"
s2="bbbbb"
s3="pwwkew"
s4="au"

longestLength=LengthOfLongestSubstring()

print(longestLength.lengthOfLongestSubstring(s1))
print(longestLength.lengthOfLongestSubstring(s2))
print(longestLength.lengthOfLongestSubstring(s3))
print(longestLength.lengthOfLongestSubstring(s4))