LeetCode-3-无重复字符的最长子串-Java&Python

最新推荐文章于 2024-06-15 23:59:10 发布

原创最新推荐文章于 2024-06-15 23:59:10 发布 · 300 阅读

0 ·

CC 4.0 BY-SA版权

python 同时被 3 个专栏收录

13 篇文章

订阅专栏

java

9 篇文章

订阅专栏

leetcode

9 篇文章

订阅专栏

本文详细解析了LeetCode上“最长无重复子串”问题的多种解法，包括Java和Python的实现，探讨了滑动窗口和HashMap数据结构的应用，以及不同写法对执行效率的影响。

1.题目

https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

2、实现

Java

数据结构：hashmap，key的唯一性

思路：滑动窗口，map的（key,value）存放string s的（s.charAt(i),i），map的key是唯一的，但是put相同key的value1，会更新。用start表示字符串的开始位置，i为当前游标，如果当前字符 s.charAt(i) 已经存在map的keySet中，并且当前的start不大于s.charAt(i) 对应的map中存在的之前添加的Preindex (map.get(s.charAt(i)))，就把start滑动到Preindex后一位

即，如果 s[i]在 [start ,i) 范围内有与之重复的字符s[i′ ]，我们直接跳过 [start，i'] 范围内的所有元素，并将 start 变为 i' + 1

写法一：增加显示判断 strat<=i' ，并且只有在start改变时，ans才会改变，才需要max对比当前和之前的长度，这个方法提交后执行效率都优于以下其他写法

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int start=0,ans=0;
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0;i<s.length();i++){
            if(map.containsKey(s.charAt(i))&&start<=map.get(s.charAt(i))){
                start=map.get(s.charAt(i))+1;         
            }else{
                ans=Math.max(ans,i-start+1);
            }           
            map.put(s.charAt(i),i);            
        }
        return ans;
    }
}

写法二： start更新时直接用max计算

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int start=0,ans=0;
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0;i<s.length();i++){
            if(map.containsKey(s.charAt(i))){
                start=Math.max(map.get(s.charAt(i))+1,start);              
                
            }
            ans=Math.max(ans,i-start+1);
            map.put(s.charAt(i),i);            
        }
        return ans;
    }
}

写法三：加边界条件

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n=s.length();
        if (n==0||n==1){
            return n;
        }
        int start=0,ans=0;
        Map<Character,Integer> map=new HashMap<>();
        for(int i=0;i<n;i++){
            if(map.containsKey(s.charAt(i))&&start<=map.get(s.charAt(i))){
                start=map.get(s.charAt(i))+1;         
            }else{
                ans=Math.max(ans,i-start+1);
            }           
            map.put(s.charAt(i),i);            
        }
        return ans;
    }
}

Python

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        if len(s)=="":return 0
        if len(s)==1:return 1
        d_map = {}
        start = ans = 0
        for i in range(len(s)):
            if s[i] in d_map and start<=d_map[s[i]]:
                start = d_map[s[i]] + 1
            else:
                ans = max(ans, i - start + 1)
            d_map[s[i]] = i
        return ans

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        if len(s)=="":return 0
        if len(s)==1:return 1
        d_map = {}
        start = ans = 0
        for i in range(len(s)):
            if s[i] in d_map:
                start = max(d_map[s[i]] + 1,start)
            ans = max(ans, i - start + 1)
            d_map[s[i]] = i
        return ans

边界判断换成 for in 执行时间就边长了，虽然写法很python,但效率却不如显式直接判断

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        n=len(s)
        if n in (0,1):
            return n
        d_map = {}
        start = ans = 0
        for i in range(n):
            if s[i] in d_map and start<=d_map[s[i]]:
                start = d_map[s[i]] + 1
            else:
                ans = max(ans, i - start + 1)
            d_map[s[i]] = i
        return ans

3、本题中语言点

set 和第2第中用到的一样

4、就提交效率对比，显式条件判断，比调用函数执行效率高

if len(s)=="":return 0
if len(s)==1:return 1

if n in (0,1):
return n

if(map.containsKey(s.charAt(i))&&start<=map.get(s.charAt(i))){
start=map.get(s.charAt(i))+1;
}

if(map.containsKey(s.charAt(i))){
start=Math.max(map.get(s.charAt(i))+1,start);

}

后记：

后来突然想明白一个问题：这里的判断start<=map.get(s.charAt(i)) ，其实是使用map数据结构导致的影响。

单纯考虑到滑动窗口，只会想到窗口沿找index增大的方向往后滑动，但是当用map一直在存数据的时候，滑动窗口开始位置start之前的那些曾经放入map的元素并没有从map中删除过，一直存在map里面，所以有可能会start>map.get(s.charAt(i))。因为我们窗口要向后滑动，所以这里必须要加条件限制start<=map.get(s.charAt(i))