LC3. 无重复字符的最长字串

解法多种多样，但是其本就就是一个滑动窗口或者说双指针，我们维护一个无重复元素的窗口，然后不断让其向右侧滑动。主要步骤非常清晰

1. 右指针移动至新字符
2. 若窗口内未包含新字符，则右指针继续移动
3. 若窗口内包含新字符，则移动左指针，将新字符上一次出现的位置移出窗口（注意此过程可能会从窗口中移除多个元素）

看似花里胡哨的各种解法，其根本思路基本上就是上面说的那样，所以来看一下整个过程有哪些地方可以玩出幺蛾子

• 右指针移动，显然玩不出花来，我能想出来的，顶多就是可以不维护右指针索引，然后通过窗口本身记录元素数量，但好像并没有什么意思
• 窗口内是否包含新元素，这个地方就有不少办法了，比较常见的
  1. 暴力
  2. 哈希表
  3. 字符串的indexOf()方法
• 左指针的移动，这里也有一些变数
  1. 老老实实的滑
  2. 哈希表的迅速定位
  3. 数组模拟哈希表
  4. 字符串的indexOf()

---

下面给出一些解法的代码

BF

/**
 * 暴力解法，时间复杂度O(n^3)
 * @param s
 * @return
 */
public int lengthOfLongestSubstring(String s) {
    if(s == null || s.length() == 0)return 0;
    int ret = 1;
    for (int i = 0; i < s.length(); i++) {
        for (int j = i; j <s.length() ; j++) {
            if (check(s,i,j)) {
                ret = Math.max(ret, j - i + 1);
            }
        }
    }
    return ret;
}

/**
 * 检查字符串s中start--end之间是否有重复字符
 * @param s
 * @param start
 * @param end
 * @return
 */
private boolean check(String s, int start, int end) {
    Set<Character> set = new HashSet<>();
    for (int i = start; i <=end ; i++) {
        if (set.contains(s.charAt(i))) {
            return false;
        }
        set.add(s.charAt(i));
    }
    return true;
}

---

质朴的双指针滑窗

/**
 * 双指针，时间复杂度O(n)
 * @param s
 * @return
 */
public int lengthOfLongestSubstring2(String s) {
    if(s == null || s.length() == 0)return 0;
    Set<Character> set = new HashSet<>();
    int ret = 1;
    for (int left = 0, right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        if (set.contains(c)) {
            while (s.charAt(left) != c) {
                set.remove(s.charAt(left));
                left++;
            }
            set.remove(s.charAt(left));
            left++;
        }
        set.add(c);
        ret = Math.max(right-left+1,ret);
    }
    return ret;
}

---

利用map

/**
 * 利用map，时间复杂度O(n)
 * @param s
 * @return
 */
public int lengthOfLongestSubstring3(String s) {
    if(s == null || s.length() == 0)return 0;
    int ret = 1;
    // left是无重复字符串开始的位置
    int left = 0;
    // map中，key是字符，value是该字符出现的上一个位置
    Map<Character, Integer> map = new HashMap<>();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (map.containsKey(c)) {
            left = Math.max(left, map.get(c)+1);
        }
        ret = Math.max(ret, i - left + 1);
        map.put(c, i);
    }
    return ret;
}

---

数组模拟map

/**
 * 数组代替map
 * @param s
 * @return
 */
public int lengthOfLongestSubstring4(String s) {
    if(s==null || s.length() == 0)return 0;
    int ret = 0;
    int[] map = new int[128];
    int left = 0;
    for (int i = 0; i < s.length(); i++) {
        left = Math.max(left, map[s.charAt(i)]);
        ret = Math.max(ret, i - left+1);
        map[s.charAt(i)] =i+1;
    }
    return ret;
}

---

字符串的indexOf方法

/**
 * 利用字符串的indexOf
 * @param s
 * @return
 */
public int lengthOfLongestSubstring5(String s) {
    if(s==null || s.length() == 0)return 0;
    int ret = 0;
    for (int left=0, right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        int position = s.substring(left, right).indexOf(c);
        // 需要移动左指针的情况
        if (position >= 0) {
            left = left + position + 1;
        } else {
            ret = Math.max(ret, right - left + 1);
        }
    }
    return re