Longest Substring Without Repeating Characters

这是O(N)的方法，维护窗口的左边和右边，右边不断向左走，当发现这个窗口里面有重复的时候，我们移动左边到重复元素的下一个，跳过中间的字符，因为不会比现在的max更长，而且也始终包含重复的字符。走到无重复了，我们继续移动右边。所以，表面看上去有while loop嵌套在另一个while loop里面，但是我们不重复之前走过的位置，所以时间复杂度还是O(N)的。

public int lengthOfLongestSubstring(String s) {        if(s==null || s.length() == 0) return 0;        HashSet<Character> set = new HashSet<Character>();        int max = 0;        int walker = 0;        int runner = 0;        while(runner < s.length()){            if(set.contains(s.charAt(runner))){                max = Math.max(runner-walker,max);                                while(s.charAt(walker)!=s.charAt(runner)){                    set.remove(s.charAt(walker));                    walker++;                }                walker++;            }            else set.add(s.charAt(runner));            runner++;        }        max = Math.max(max,runner-walker);        return max;    }

下面是动态规划思维用hashset维护一个装满前面遇到的所有char的集合，只要集合增加我们的max就增加，一旦重复，就从头查看。但是因为是O(N*N)的时间复杂度，所以果断TLE过不了的囧。

public int lengthOfLongestSubstring(String s) {        if(s==null || s.length() == 0) return 0;        int len = s.length();        int i = 0;        int j = 1;        int max = 0;        HashSet<Character> set = new HashSet<Character>();        while(i < len) {            set.add(s.charAt(i));            j = i + 1;            while(j < len) {                if(!set.contains(s.charAt(j))) {                    max = Math.max(j - i, max);                    set.add(s.charAt(j));                      j++;                    //i++;                }                else {                    set.clear();                     break;                }            }            i++;        }        return max;    }