leetcode Longest Substring Without Repeating Characters

python实现

方法一（自己实现，192 ms）：

成就：Runtime: 192 ms, faster than 25.18% of Python3 online submissions for Longest Substring Without Repeating Characters.
空间复杂度O（n），时间复杂度O（n*m）
思路：从第一个字母开始，判断是否在结果字符串中（结果字符串开始是空字符串），不在就添加到结果字符串的最后，否则就将发现这个字符以及它前面的字符都删掉，并将这个字符放到结果字符串的最后。（python中一次find的复杂度是O（n），同时python中字符串截断操作相当于重新复制一份数据，空间复杂度也是O（n），m表示查找字符串总长，n表示最长的不同字符子串）。

def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        ss_result = ""
        max_length = 0
        for _s in s:
            ss_result = ss_result[ss_result.find(_s) + 1:]
            ss_result = ss_result + _s
            max_length = max_length if len(ss_result) <= max_length else len(ss_result)
        return max_length

方法二（自己实现，116 ms）：

成就：Runtime: 116 ms, faster than 50.51% of Python3 online submissions for Longest Substring Without Repeating Characters.
空间复杂度O（n），时间复杂度O（n*m）
思路：方法二的时间与空间复杂度与方法一 一样，之所以运行时间变少了，是因为方法二中结果字符串如果没有找到相同的字符，则不会进行复制的操作。

def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        max_length = 0
        start_loc = 0
        end_loc = 0
        offset = start_loc
        for _s in s:
            find_loc = s[start_loc:end_loc].find(_s)
            end_loc += 1
            if find_loc != -1:
                start_loc = find_loc + 1 + offset
                offset = start_loc
            else:
                length = end_loc - start_loc
                max_length = max_length if length <= max_length else length
        return max_length

方法三（自己实现，92 ms）：

成就：Runtime: 92 ms, faster than 74.78% of Python3 online submissions for Longest Substring Without Repeating Characters.
空间复杂度O（n），时间复杂度O（n*m）
思路：根据方法二的启发，结合了方法一与方法二，小小的改动提高了效率。

def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        ss_result = ""
        max_length = 0
        for _s in s:
            find_loc = ss_result.find(_s)
            if find_loc != -1:
                ss_result = ss_result[ss_result.find(_s) + 1:]
            ss_result = ss_result + _s
            max_length = max_length if len(ss_result) <= max_length else len(ss_result)
        return max_length

备注

其实时间复杂度是O（nm）有失偏颇，因为python的字符串查找函数find()是使用Boyer- Moore算法实现的，因此时间复杂度低于O（nm）。

java实现

方法一（自己实现，36 ms）：

成就：Runtime: 36 ms, faster than 51.91% of Java online submissions for Longest Substring Without Repeating Characters.
空间复杂度O（n），时间复杂度O（n*m）
思路：与python中的方法3一样。

public int lengthOfLongestSubstring(String s) {
        int maxNum = 0;
        String temp = "";

        for (int i = 0; i < s.length(); i++) {
            char tempChar = s.charAt(i);
            int num = temp.indexOf(tempChar);
            if (num == -1) {
                temp = temp + s.charAt(i);
                maxNum = maxNum > temp.length() ? maxNum : temp.length();
            }
            else {
                temp = temp.substring(num + 1);
                temp = temp + s.charAt(i);
            }
        }
        return maxNum;
    }