題目：

Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. For "bbbbb" the longest substring is "b", with the length of 1.

找出最長不重複的連續子串。

題目解析：

題意很簡單，就是要找到最長的連續的子串。

思路一：

最先考慮到的就是求第i位字元開頭的，最大的子串長度。沒增加第j位的字元，就要與i -- j-1之間的字元相比較，直到出現重複或者遍歷完為止。這也是最複雜的，需要O(n^2)時間複雜度。中間要設定一個maxlen變數，判斷第i位開始的字元是否超過了最大長度。

思路二：

我們可以從《最大連續子陣列和》得到啟發，我們求第i位字元結尾的最大長度：遍歷到第i位的時候，如果和前面不重複，就max++（這裡為max不是maxlen）；如果重複，通過遍歷從i-maxlen到i-1位的字元，與第i位字元相比較，找到相等的位j，那麼maxlen可能會被i-j更新！

然後再遍歷i+1位的字元。。。

這個思路比上面的有一點改進，不過也是需要比較後才能得到，時間複雜度也有一點高。

思路三：

通常我們要降低時間複雜度，可以考慮犧牲空間來獲得。

我們通過hash表，並附設兩個“指標”i和j；用字元的整數值當索引，值為0或1表示是否之前存在。當存在了，就將i++並清零，直到j所表示的字元被清零為止。

比如abcdba，當j等於4的時候，arr[1]是為1的，此時i為0，那麼先將arr[0]和arr[1]清零，然後再對arr[1]賦值為1。

int LengthOfLongestSubstring(char *str)
{
    int i,j;
    int maxlen = 0; //要初始化，不然產生意外結果！
    int n = strlen(str);
    int arr[256] = {0};     //設定hash表，索引為字元的值，值為是否存在該字元！

    for(i = 0,j = 0;j < n;j++){
        while(arr[str[j]] == 1){
            arr[str[i]] = 0;
            ++i;
        }
        arr[str[j]] = 1;
        maxlen = maxlen > (j-i) ? maxlen : j-i+1;
    }

    return maxlen;
}
 

思路四：

通常我們能想到用雜湊表，但是往往在索引和值表示的概念上造成混亂。一般索引用要判斷字元是否存在的字元值來表示，而值就是我們關心的是否存在，這就得出了思路三。但進一步想想，我們知道了他存在，但還想知道具體位置。

方案一：我們可以再另外附設一個數組，來表示其儲存的位置

用一個start和end來記錄目前考察的字串的開頭和結尾
用exist[26]來記錄目前字串中出現過的字母
用position[26]來記錄出現過的字串的字母的位置

然後我們往後走一位，然後和exist來比較看這個字母是否已經出現過了。

1 如果出現過了，那麼我們把start移動到之前那個字母出現的位置的後一位，end往後移動一位
2 如果沒有出現過，那麼我們就把end往後移動一位

程式碼：

int lengthOfLongestSubstring(string s) 
{
    int max = 0, start = 0;
    bool exist[26];
    int position[26];
    
    for(int i = 0; i < 26; i++) {
        exist[i] = false;
        position[i] = 0;
    }
    
    for(int i = 0; i < s.size(); i++) {
        if(exist[s[i] - 'a']) {
            for(int j = start; j <= position[s[i] - 'a']; j++) {
                exist[s[j] - 'a'] = false;
            }
            start = position[s[i] - 'a'] + 1;
            exist[s[i] - 'a'] = true;
            position[s[i] - 'a'] = i;
        }
        else {
            exist[s[i] - 'a'] = true;
            position[s[i] - 'a'] = i;
            max = max > (i - start + 1) ? max : (i - start + 1);
        }
    }

    return max;
}

方案二：

-----錯誤的做法！！！比如abbbbbba應該輸出2，但是按照這個的話，會輸出7。

我們不僅要儲存位置，還要取 len = min(len+1,j-index); if(len > max) max = len。之所以要取最小值，是因為len的長度要麼大幅度減小，要麼一個一個增加，而j-index可能很大。

我們完全可以讓思路三中的arr[]陣列儲存位置即可！當存在了，就更新其為最新的位置即可。當已經存在了，就將j-index與最大長度相比，看是否更新，並將索引陣列更新為j。

程式碼如下：

int LengthOfLongestSubstring1(char *str)
{
    int idex = -1,j;
    int maxlen = 0; //要初始化，不然產生意外結果！
    int n = strlen(str);
    int arr[256];     //設定hash表，索引為字元的值，值為是否存在該字元！

    memset(arr,-1,256 * sizeof(int));   //設定的是位元組數，因此要乘以sizeof(int)
    for(j = 0;j < n;j++){
        if(arr[str[j]] > -1){
            idex = arr[str[j]];
        }
        arr[str[j]] = j;
        if(j-idex > maxlen)
            maxlen = j-idex;
    }

    return maxlen;
}

正確程式碼：

class Solution {
public:
    int lengthOfLongestSubstring(string s){
        int idex = -1,j;
        int maxlen = 0,len = 0; //要初始化，不然產生意外結果！
        int n = s.size();
        if(n == 0)
            return 0;
        int arr[256];     //設定hash表，索引為字元的值，值為是否存在該字元！
    
        memset(arr,-1,256 * sizeof(int));   //設定的是位元組數，因此要乘以sizeof(int)
        for(j = 0;j < n;j++){
            idex = arr[s[j]];
            arr[s[j]] = j;
            len = len+1 > j-idex ? j-idex : len+1;
            if(len > maxlen)
                maxlen = len;
        }

        return maxlen;
    }
};