3.无重复字符的最长子串（窗口滑动）

 

题目

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

 

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:

输入: s = ""
输出: 0
 

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

（解法越到后面越优）

解法一：

暴力破解法，时间复杂度O(n²)  两个层for循环，两个指针，i，j，从i开始，j向后遍历一个一个移动， 每移动一次将此位置的字符放入set集合中，由于集合中不存在两个重复的元素，所以，每次移动时，比较set的长度（从i到j不重复字符的数目）是否和j-i+1（即从i到j的所有字符）一致，  一旦不一致，说明i，j之间有重复的字符了，记录一下长度和max比较 取最大值，清空set， i向后移动一位，继续如此操作。

class Solution {
    public int lengthOfLongestSubstring(String s) {
       int maxleng=0;
        if (s.length()==0){
            return 0;
        }
        if (s.length()==1){
            return 1;
        }

        Set set = new HashSet();
        int b ;
        for(int i = 0;i<=s.length()-1;i++){
            set.clear();
            set.add(s.charAt(i));
            for (int j=i+1;j<=s.length()-1;j++){
                set.add(s.charAt(j));
                b = set.size();
                if( b > maxleng) {
                    maxleng = b;

                }
                if(b < j-i+1){
                    break;
                }
            }
        }
        return maxleng;
    }
}

tips：

1.Set  set1 = new HashSet（）；创键一个新的集合；

  set.clear() 清空当前集合

  set.add() 添加一个新的元素（括号里面写新添加的值）

set.remove(Object o) //如果 set 中存在指定的元素，则将其移除（可选操作）。

set.contains(Object o) //如果 set 包含指定的元素，则返回 true。

set.size() //返回 set 中的元素数（其容量）

2.字符串中取第i位上的对应的字符 s.charAt(i);

 

解法二

上面的方法右指针每次都重新开始，事实上不用重新开始，因为右指针遍历过的这些没有重复的字符，再遍历一遍浪费时间，所以set也不用清空，需要将左指针指向的元素删去即可。

i为右指针，head为左指针，右指针一直向右移动，，每次移动，判断当前元素是否z在set中有过了 如果没有 向set中添加新元素，如果有过了，就是重复了，这时候右指针不动，左指针向右移动，直到set中没有了重复的元素为止，右指针再继续向右移动。

class Solution {
    public int lengthOfLongestSubstring(String s) {
               int maxleng=0;
        
        Set set = new HashSet();
        int b ;

        int length1=s.length()-1;
        int head=0;
        int i = 0;
        while(i<=length1){
            if(!set.contains(s.charAt(i))){
                set.add(s.charAt(i));
                maxleng= Math.max(i-head+1,maxleng);
                ++i;
            }
            else{
                set.remove(s.charAt(head));
                head++;             
            }
//            maxleng= Math.max(i-head+1,maxleng);

        }
        return maxleng;

下面是官方的题解， 思路一样，但是不知道为什么 它的运行速度总是比我快1ms-2ms。

class Solution {
    public int lengthOfLongestSubstring(String s) {

       // 哈希集合，记录每个字符是否出现过
        Set<Character> occ = new HashSet<Character>();
        int n = s.length();
        // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
        int rk = -1, ans = 0;
        for (int i = 0; i < n; ++i) {
            if (i != 0) {
                // 左指针向右移动一格，移除一个字符
                occ.remove(s.charAt(i - 1));
            }
            while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
                // 不断地移动右指针
                occ.add(s.charAt(rk + 1));
                ++rk;
            }
            // 第 i 到 rk 个字符是一个极长的无重复字符子串
            ans = Math.max(ans, rk - i + 1);
        }
        return ans;

Tips：

求最大值  直接用Math.max();

 

解法三：

在上面的过程中，当有重复的元素了，右指针不动，左指针移动到 和  右指针的元素相同 的元素的位置  是一个一个移动，如果直接左指针直接跳到第一个重复元素的下一个元素，效率会高些，这样需要记录一下每个元素的位置，这里可以用Map;

大体上思路和上面一个解法差不多， map中key是字符值 value是字符所在的索引值。遍历的时候如果map中已经有了这个元素，同时这个重复元素第一次出现的位置在头指针head后面，才能更新头指针和删去第一个重复的元素，添加第二个重复的元素（在map中操作直接更新字符所在的索引位置即可）。    tmmzuxt  答案应该是mzuxt 是5  但假如没有上面字体加粗的这个条件  程序会运行6 因为，在右指针遍历到最后一个t的时候  发现有重复了，头指针会向前移动到 t后面进行计数。

class Solution {
    public int lengthOfLongestSubstring(String s) {
                      int maxleng=0;


        Map<Character, Integer> map = new HashMap<Character, Integer>();

        int length1=s.length()-1;
        int head=0;
        int i = 0;
        while(i<=length1){
            if(map.containsKey(s.charAt(i)) && map.get(s.charAt(i))>=head){
                head=map.get(s.charAt(i)) +1;
                map.put(s.charAt(i),i);
                ++i;
            }
            else{
                map.put(s.charAt(i),i);
               // maxleng= Math.max(i-head,maxleng);
                ++i;
            }
            maxleng= Math.max(i-head+1,maxleng);
        }
        return maxleng;

}
}

Tips：map的相关操作

解法四（最优）

思路和上面解法三都一样，但是相对于上面的map ，这个改用了数组，方法是，将各个字符本身都有其对应的ascii码，创建一个128长度的整形数组 0-127 对应着各个字符，对应元素存储 字符出现过的 最后一次的位置(从1开始，0代表没出现过)，i为左指针，j为右指针，j指针遍历，（这里因为对应每个字母的位置都能直接取到  比在上面解法map中查找是否存在字母 更快。） j取到当前字母 的上次出现过的位置，如果发现上次出现的位置不是0 且 在左指针右边（与解法三中的if判断道理相同）说明重复了，就该跳动左指针 到重复的上一次地方，而这里的判断更简单，只要判断位置比左指针的位置大就行，一举两得。

最后j每次都会更新字母最后出现的位置并且 递加。

public static int lengthOfLongestSubstring(String s) {
        int maxleng=0;


       int[] arr = new int [128];
       int i=0, j=0;
       while(j<s.length()){
           int ascii =s.charAt(j);
           if(arr[ascii]>i){
               i=arr[ascii];
           }
           arr[ascii] = j+1;
           maxleng = Math.max(maxleng,j-i+1);
           j++;
       }
              return maxleng;
    }

 

这算是窗口滑动一类题，两个指针 向右走，尽量减少重复的判断 ，如果有遍历的情况，可以牺牲空间换取时间，解法一二三中的 判断包含 的函数也算是遍历了。