LeetCode-3-無重複字符的最長子串（longest-substring-without-repeating-characters）

題目描述

Given a string, find the length of the longest substring without repeating characters.

給定一個字符串，請你找出其中不含有重複字符的 最長子串 的長度。

示例 1:

輸入: "abcabcbb"
輸出: 3 
解釋: 由於無重複字符的最長子串是 "abc"，因此其長度爲 3。

示例 2:

輸入: "bbbbb"
輸出: 1
解釋: 由於無重複字符的最長子串是 "b"，因此其長度爲 1。

示例 3:

輸入: "pwwkew"
輸出: 3
解釋: 由於無重複字符的最長子串是 "wke"，因此其長度爲 3。
     請注意，你的答案必須是 **子串** 的長度，"pwke" 是一個子序列，不是子串。

<!--more-->

個人垃圾思路

One

1. 剛開始想耍一些"小聰明"，看有沒有巧妙的方法解決，當時用了相似於Node的先後'指針'的方式發現有些用例是過不了的
2. 後面用到了相似"滑窗"的方法，碰到重複字符則將滑窗寬度歸零，且位置回到被重複字符的下一位置。
3. 但會出現死循環，由於沒把以前被重複的字符remove掉 -- 後面發現只remove掉那個重複的字符的話，有些沒有重複的字符在回退以後再次計算的時候，會發生混亂<font color=grey size=2>(回退後再次走到以前不重複的字符時候，由於hash表中已經在第一次put過了，因此此次必定會發生重複狀況)</font>
4. 因此上面把滑窗歸零的時候是真正的歸零，包括存數據的hash表

上面方法應該是 $ O(n^2) $ ,由於會發生例如abcdea在最後a發生重複，就會徹底回退到b位置---so low ；提交記錄耗時大概80+ms

Two

1. 第二個方法是也兩個指針相似滑窗， k指針一直前進，發生重複時j指針移動到被重複字符的下一位置，可是隻能往右移動，不能回退
2. 將map<Character,Integer>中存放的以前被重複字符的value(即字符所在的索引)換爲當前發生重複的字符位置 -- 不是被重複字符
3. 循環中一直保持max最大
4. 當有其中一個指針到達終點時，就能夠退出了 ；因爲j,k表明的都是索引，因此最後結果 爲max+1

Three

1. 第二種方法發現 k一直在++，其實就至關於for循環的 i++，因此就換成for循環了 -- 複雜度應該是 $ O(n) $

Two和Three 提交的耗時6ms,佔用內存35M--佔用內存居然超過了 100%的java用戶ヽ(°◇° )ノ

個人垃圾代碼

package com.dasnnj.practice.medium;

import java.util.HashMap;
import java.util.Map;

/**
 * Description <p> TODO:
 * 給定一個字符串，請你找出其中不含有重複字符的 最長子串 的長度。
 * <p>
 * 示例 1:
 * <p>
 * 輸入: "abcabcbb"
 * 輸出: 3
 * 解釋: 由於無重複字符的最長子串是 "abc"，因此其長度爲 3。
 * 示例 2:
 * <p>
 * 輸入: "bbbbb"
 * 輸出: 1
 * 解釋: 由於無重複字符的最長子串是 "b"，因此其長度爲 1。
 * 示例 3:
 * <p>
 * 輸入: "pwwkew"
 * 輸出: 3
 * 解釋: 由於無重複字符的最長子串是 "wke"，因此其長度爲 3。
 * 請注意，你的答案必須是 子串 的長度，"pwke" 是一個子序列，不是子串。</p>
 *
 * @author DASNNJ <a href="mailto:dasnnj@outlook.com.com"> dasnnj@outlook.com </a>
 * @date 2019-05-08 13:17
 */
public class LongestSubstringWithoutRepeatingCharacters {
    public static void main(String[] args) {
        LongestSubstringWithoutRepeatingCharacters l = new LongestSubstringWithoutRepeatingCharacters();
        System.out.println(l.lengthOfLongestSubstring(""));
    }

    public int lengthOfLongestSubstring(String s) {
        //One
        /*char[] chars = s.toCharArray();
        Map<Character, Integer> map = new HashMap<>(8);
        //計算非重複字符的長度
        Integer len = 0;
        int max = 0;
        //索引
        Integer index;
        for (int i = 0; i < chars.length; i++) {
            //若是是正常進行
            //若是重複
            if ((index = map.get(chars[i])) != null) {
                //回退到重複的位置，從重複位置的下一位從新算，至關於捨棄兩個重複字符中的第一個
                i = index;
                //長度歸零
                len = 0;
                //將map清空，從重複位置的下一位置從新計算 -- 清空是由於第一個重複的在上面提到是至關於捨棄，不清空的話會影響下次循環的判斷
                map.clear();
            } else {
                //沒重複固然正常put  正常++
                map.put(chars[i], i);
                len++;
            }
            //每次循環都保持max最大
            if (len > max) {
                max = len;
            }
        }
        return max;*/

        if ("".equals(s)) {
            return 0;
        }
        char[] chars = s.toCharArray();
        //j k,用於Two方法的兩個指針---後面發現直接用for循環便可
        int j = 0, k = 0, max = 0;
        Integer ele;
        Map<Character, Integer> sets = new HashMap<>(16);

        //Three
        for (int m = 0; m < chars.length; m++) {
            //若是發生重複
            if ((ele = sets.get(chars[m])) != null) {
                // j指針指向兩個重複字符中的第一個的下一位置，j指針不能後退，只能前進，因此下面有個判斷
                if (j < ele + 1) {
                    j = ele + 1;
                }
            }
            //不重複則是正常put，重複狀況1.將j指針指向原字符的下一位2.用新字符替換掉map中原字符（主要是爲了替換map中key爲此字符 的value值也就是索引）
            sets.put(chars[m], m);
            //每次循環保持max最大
            if (max < m - j) {
                max = m - j;
            }
        }

        //Two  原理同Three
        /*while (j < chars.length && k < chars.length) {
            if ((ele = sets.get(chars[k])) != null) {
                if (j < ele + 1) {
                    j = ele + 1;
                }
            }
            sets.put(chars[k], k);
            k++;

            if (max < k - j) {
                max = k - j;
            }
        }*/
        return max + 1;
    }
}