每天一道算法题（1）

1、求一个字符串连续不重复子串的最长长度

即比较经典的移动游窗，将字符放入队列中，当有重复字符时则移动左标，最后取左右标间隔最大的。

有两种方式可以实现，第一种比较简单的list方式 

// list方式
    public static int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) {
            return 0;
        }
        String[] strArr = s.split("");
        List<String> templist = new ArrayList<>();
        List<String> maxList = new ArrayList<>();

        for (int i = 0; i < strArr.length; i++) {
            // 判断如果不同，则放到tempList里
                if (!templist.contains(strArr[i])) {
                    templist.add(strArr[i]);
                } else {
                    // 如果已经存在，判断是否最大，如果最大则更新maxlist
                    // 将tempList中重复字符串前面的字符删除
                    if (templist.size() > maxList.size()) {
                        maxList = templist;
                    }
                    int repeatIndex = templist.indexOf(strArr[i]);
                    for(int j=0; j<=repeatIndex; j++) {
                        templist.remove(0);
                    }
                    templist.add(strArr[i]);
                }
            }
        return maxList.size() > templist.size() ? maxList.size(): templist.size();
    }

    

第二种经典的hash方式，比较简洁而且时间复杂度低一些

// hashmap方式，滑动窗口，左右游标
    public static int lengthOfLongestSubstring1(String s) {
        if (s.length() == 0) {
            return 0;
        }
        // 左游标
        int left = 0;
        int max = 0;
        Map<Character, Integer> map = new HashMap();
        for(int i = 0; i < s.length(); i++) {
            if (map.containsKey(s.charAt(i))) {
                // 滑动左游标到重复字符串后一个位置,如果重复字符串在前面，那left会跑回去，所以需要取最大
                left = Math.max(left, map.get(s.charAt(i)) + 1);
            }
            //更新最大长度
            max = Math.max(max, i - left + 1);
            // 每次将字符放入
            map.put(s.charAt(i), i);
        }
        return max;
    }

    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring1("abba"));
    }

第三种方式，使用滑动窗口，比上述方式更通用一些

    /**
     * 双指针滑动窗口，先移动右指针，然后在有重复字符时移动左指针，在这之中取最大
     * c++操作会比较方便，java需要更新map中value的个数,略烦琐
     * @param s
     * @return
     */
    public static int lengthOfLongestSubstring2(String s) {
        Map<Character, Integer> window = new HashMap<>();
        int left,right,max;
        left=right=max=0;
        while (right < s.length()) {
            char c = s.charAt(right);
//            Integer integer = window.get(c);
//            integer = integer == null ? 1:integer+1;
//            window.put(c, integer);
            // 用如下方式，顶上面三行代码
            window.put(c, window.getOrDefault(c, 0) + 1);
            right++;

            while (window.get(c) != null && window.get(c) > 1) {
                char c1 = s.charAt(left);
                Integer integer1 = window.get(c1);
                integer1 = integer1 == null ? null:integer1-1;
                window.put(c1, integer1);
                left++;
            }
            max = Math.max(max, right-left);
        }
        return max;
    }