LeetCode-Longest Substring Without Repeating Characters

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

 

这道题考察如何维护一个window。

public class Solution {
   public static int lengthOfLongestSubstring(String s) {
        if(s == null || s.length()==0){
            return 0;
        }
        
        int len = s.length();    
        int l = 0;
        int r = 1;
        int maxLength = 1;
       
        
        HashSet<Character> set = new HashSet<Character>();
        set.add(s.charAt(l));
        
        while(r < len){
            if(!set.contains(s.charAt(r))){
                set.add(s.charAt(r));
                r ++;         
                maxLength = Math.max(maxLength, r-l);
                
                if(r == len){
                    return maxLength;
                }
                
            }
            else{
                while(s.charAt(l) != s.charAt(r)){
                    set.remove(s.charAt(l));
                    l ++;
                }
                l ++;
                r ++;   
                if(r == len){
                    return maxLength;
                }
            }
            
        }
        
        return maxLength;
    }
}

 另一种可以通过OA 的方法：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        int res = 1;
        for (int i=0; i<s.length(); i++){
            int cursor = 0;
            Map<Character, Integer> map = new HashMap();
            for (int j = i; j < s.length(); j++){
                char c = s.charAt(j);
                if(!map.containsKey(c)){
                    cursor++;
                    map.put(c, 1);
                }
                else{
                    break;
                }
            }
            if(cursor > res){
                res=cursor;
            } 
        }
        return res;
    }
}

　　利用hashmap存储不重复子串，key为字符，value为此字符的位置。从前向后进行遍历，只要map 中没有当前字符，便将其加入map 。并将子串长度加一。若当前字符已经出现在map 中，获得map中 此字符的位置，清除此位置以及之前的的所有key 。从此位置之后重新计算子串，保证了子串的不重复。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        Map<Character, Integer> map = new HashMap<>();
        int start = 0;
        int maxLen = 0;
        int curLen = 0;
        for(int i=0; i<s.length(); i++){
            char c = s.charAt(i);
            if(!map.containsKey(c)){
                curLen++;
                if(curLen>maxLen){
                    maxLen = curLen;
                }
                map.put(c, i);
            }
            else{
                int index = map.get(c);
                for(int j = start; j<=index; j++){
                    map.remove(s.charAt(j));
                }
                map.put(c, i);
                start = index+1;
                curLen = i - index;
            }
            
        }
        return maxLen;
    }
}

　　二刷：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        if(s == null || s.length() == 0){
            return 0;
        }
        Map<Character, Integer> map = new HashMap<>();
        int left = 0, right = 0;
        int max = 0, temp = 0;
        
        while(right < s.length()){
            if(!map.containsKey(s.charAt(right))){
                temp++;
                if(temp > max){
                    max = temp;
                }
            }
            else{
                for(int i = left; i < map.get(s.charAt(right)); i++){
                    map.remove(s.charAt(i));
                }
                left = map.get(s.charAt(right))+1;
                temp = right - map.get(s.charAt(right));
            }
            map.put(s.charAt(right), right);
            right++;
        }
        return max;
    }
}