leetcode-3-无重复字符的最长子串(longest substring without repeating characters)-java

题目及测试

package pid003;
/*无重复字符的最长子串

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

示例 1:

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

示例 2:

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

示例 3:

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




*/
public class main {
	
	public static void main(String[] args) {
		String[] testTable = {"abcabcbb","bbbbb","pwwkew"};
		for (int i=0;i<testTable.length;i++) {
			test(testTable[i]);
		}
	}
		 
	private static void test(String ito) {
		Solution solution = new Solution();
		int rtn;
		long begin = System.currentTimeMillis();
		System.out.println("ito="+ito);
		rtn = solution.lengthOfLongestSubstring(ito);//执行程序
		long end = System.currentTimeMillis();		
		System.out.println("rtn="+rtn);
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，60ms，较快）

从头到尾一次遍历，设置一个队列，先进先出，设置一个map，放置现在字符串的char
 i每增加一个，如果map中已有这个char，那么从队列不断退出字符，直到等于现在的char，处理重复结束
 然后队列加入这个char，map设置这个char，nowlength++,如果现在长度大于max，那么max=now

package pid003;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;

public class Solution {
public int lengthOfLongestSubstring(String s) {
    int length=s.length();
    if(length==0||length==1){
    	return length;
    }
    HashMap<Character, Boolean> map=new HashMap<>();
    Queue<Character> queue=new LinkedBlockingQueue<Character>();
    int nowLength=0;
    int maxLength=0;
    for(int i=0;i<length;i++){
    	Character now=s.charAt(i);
    	if(map.containsKey(now)){
    		while(true){
    			Character prev=queue.remove();
    			map.remove(prev);
    			nowLength--;
    			if(prev.equals(now)){
    				break;
    			}
    		}
    	}    	
    	map.put(now, true);
		nowLength++;
		queue.add(now);
		if(nowLength>maxLength){
			maxLength=nowLength;
		}
    }	
	return maxLength;
    }

}

解法2（成功，34ms，较慢）

将hashmap缓存hashset，还是滑动窗口法

    public int lengthOfLongestSubstring(String s) {
        int max=0;
        int length=s.length();
        int size=0; //当前子串的长度
        int begin=0; //子串的起始位置（包含）
        Set<Character> set=new HashSet<>();
        //一次循环结束后，子串是包含i的字符的最长的无重复字符串
        for(int i=0;i<length;i++){
        	Character now=s.charAt(i);
        	if(!set.contains(now)){
        		//当前字符是不重复的
        		set.add(now);
        		size++;
        		if(max<size){
        			max=size;
        		}
        	}else{
        		//当前字符重复
        		//从begin开始，取出字符，直到prev=now
        		while(begin<i){
        			Character prev=s.charAt(begin);
        			set.remove(prev);
        			begin++;
        			size--;
        			if(prev.equals(now)){
        				break;
        			}
        		}     
        		//减去要减的字符后，加入这次的
        		set.add(now);
        		size++;
        	}
        }    	   	
    	return max;
    }

 

解法3（别人的）

优化的滑动窗口

它可以被进一步优化为仅需要 n 个步骤。我们可以定义字符到索引的映射，而不是使用集合来判断一个字符是否存在。 当我们找到重复的字符时，我们可以立即跳过该窗口。

也就是说，如果 s[j]在 [i,j) 范围内有与 j′ 重复的字符，我们不需要逐渐增加 i。 我们可以直接跳过 [i，j′] 范围内的所有元素，并将 i变为 j′+1。

public class Solution {
    public int lengthOfLongestSubstring(String s) {
        int n = s.length(), ans = 0;
        Map<Character, Integer> map = new HashMap<>(); // current index of character
        // try to extend the range [i, j]
        for (int j = 0, i = 0; j < n; j++) {
            if (map.containsKey(s.charAt(j))) {
                i = Math.max(map.get(s.charAt(j)), i);
            }
            ans = Math.max(ans, j - i + 1);
            map.put(s.charAt(j), j + 1);
        }
        return ans;
    }
}