无重复字符的最长子串

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

(1)运用暴力法，直接取得所有子串，并判断是否有重复，不重复则和临时最大子串长度比较，求得结果。
消耗时间过多，会超出限制

public int lengthOfLongestSubstring(String s) {
 //超出时间限制
        int ans = 0;
        for(int i = 0; i < s.length(); i ++) {
            for(int j = i + 1; j <= s.length(); j ++) {
                if (allQuine(s,i,j)) {
                    ans = Math.max(ans,j-i);
                }
            }
        }
        return ans;
    }
    //一个字母一个字母判断看是否重复
    private static boolean allQuine(String s,int start,int end) {
        Set<Character> set = new HashSet<>();
        for (int i = start; i < end; i ++) {
            Character ch = s.charAt(i);
            if (set.contains(ch)) return false;
            set.add(ch);
        }
        return true;
    }

（2）滑动窗口，固定开头，向后滑动，出现重复则改变开头，继续判断向后滑动，直至完成所有；
有可能会出现重复元素访问两次

  // 滑动窗口类，元素会出现重复访问
     public int lengthOfLongestSubstring(String s) {
        Set<Character> set = new HashSet<>();
        int ans = 0, i = 0, j = 0;
        int n = s.length();
        while(i < n && j < n) {
            if (!set.contains(s.charAt(j))) {
                set.add(s.charAt(j ++));
                ans = Math.max(ans,j-i);
            } else {
                set.remove(s.charAt(i ++));
            }
        }
        return ans;
        }

（3）对滑动窗口进行优化，当有重复元素时，只需要将开头索引变成j+1即可，直到遍历全部字符串，取得最大子串长度；

public int lengthOfLongestSubstring(String s) {
    Map<Character,Integer> map = new HashMap<>();
        int n = s.length(),ans = 0;
        for (int i = 0,j = 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;
        }

总结：思考问题不要拘束，要从时间空间复杂度分析问题，尽力找最优解！