LeetCode 3: Longest Substring Without Repeating Characters

Longest Substring Without Repeating Characters

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.

解题思路

思路一：对于字符串中的每个字符，找到以该字符为起点的最长的没有重复字符的子串的长度，返回这些长度中的最大值。时间复杂度O（n²），代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int maxlen = 0;
        bool *visited = new bool[1024];
        for (int i = 0; i < s.length(); ++i) {
            memset(visited, 0, sizeof(bool) * 1024);
            int len = 1;
            visited[s[i]] = true;
            for (int j = i + 1; j < s.length(); ++j) {
                if (visited[s[j]]) break;
                visited[s[j]] = true;
                ++len;
            }

            if (maxlen < len) {
                maxlen = len;
            }
        }
        return maxlen;
    }
};

思路二：使用两个下标 i，j 分别指向当前没有重复字符的子串的起始位置和结束位置，在每次判断中，选择 i 或 j 向前移动。正常情况下移动 j，如果没有出现重复的字符则继续移动 j；如果发现重复字符，则说明子串 str[i … j] 已经不满足要求（以 i 为起点的没有重复字符的子串的最长长度为 j - i），此时需要移动 i 直到不再有重复字符为止，中间跳过的这些子串中不会有更好的结果，因为它们要么包含重复的字符要么长度更短。因为下标 i 和 j 都只向前移动，所以时间复杂度为 O(n)，空间复杂度也为O(n). 代码如下：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int n = s.length();
        int i = 0, j = 0， maxLen = 0;
        bool exist[256] = { false };
        while (j < n) {
            if (exist[s[j]]) { // 出现重复字符
                maxLen = max(maxLen, j-i); // 更新结果

                while (s[i] != s[j]) { // 移动 i 直到不再有重复字符为止
                    exist[s[i]] = false;
                    i++;
                }

                i++;
                j++; // note
            } 
            else { // 没有出现重复的字符， 移动 j
                exist[s[j]] = true;
                j++;
            }
        }
        maxLen = max(maxLen, n-i);
        return maxLen;
    }
};

思路三：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int locs[256]; // 保存字符上一次出现的位置
        memset(locs, -1, sizeof(locs));

        int idx = -1, max = 0; //idx为当前子串的开始位置-1
        for (int i = 0; i < s.size(); i++)
        {
            /*
            * 如果当前字符出现过，那么当前子串的起始位置为这个字符上一次出现的位置+1
            */
            if (locs[s[i]] > idx)
            {
                idx = locs[s[i]];
            }

            if (i - idx > max)
            {
                max = i - idx;
            }

            locs[s[i]] = i;
        }
        return max;
    }
};