滑动窗口算法

1. 无重复字符的最长子串

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:
输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:
输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

         //滑动窗口+bitmap方式 ok
    private static int lengthOfLongestSubstring5_3(String s) {
        if (s.equals("")) {
            return 0;
        }
        int end = 0;
        int maxSize = 0;
        int[] index = new int[128];//bitmap判断是否重复
        for (int start = 0; start < s.length(); start++) {
            //重复，移动左指针，并将之前保存的字符删除
            if (start != 0) {
                index[s.charAt(start - 1)] = 0;
            }
            //不重复，右移end
            while (end < s.length() && index[s.charAt(end)] == 0) {
                index[s.charAt(end)]++;
                end++;
            }
            maxSize = Math.max(maxSize, end - start);

        }
        return maxSize;
    }

2. 最小覆盖子串

给你一个字符串 S、一个字符串 T，请在字符串 S 里面找出：包含 T 所有字符的最小子串。
示例：
输入: S = “ADOBECODEBANC”, T = “ABC”
输出: “BANC”

    private static String minWindow2_76(String s, String t) {
        if (s == null || s == "" || t == null || t == "" || s.length() < t.length()) {
            return "";
        }
        //用来统计t中每个字符出现次数
        int[] needs = new int[128];
        //用来统计滑动窗口中每个字符出现次数
        int[] window = new int[128];

        for (int i = 0; i < t.length(); i++) {
            needs[t.charAt(i)]++;
        }

        int left = 0;
        int right = 0;

        String res = "";

        //目前有多少个字符
        int count = 0;

        //用来记录最短需要多少个字符。
        int minLength = s.length() + 1;

        while (right < s.length()) {
            char ch = s.charAt(right);
            window[ch]++;
            if (needs[ch] > 0 && needs[ch] >= window[ch]) {
                count++;
            }

            //移动到不满足条件为止
            while (count == t.length()) {
                ch = s.charAt(left);
                if (needs[ch] > 0 && needs[ch] >= window[ch]) {
                    count--;
                }
                if (right - left + 1 < minLength) {
                    minLength = right - left + 1;
                    res = s.substring(left, right + 1);

                }
                window[ch]--;
                left++;

            }
            right++;

        }
        return res;
    }

3. 字符串的排列

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。
换句话说，第一个字符串的排列之一是第二个字符串的子串。
示例1:
输入: s1 = “ab” s2 = “eidbaooo”
输出: True
解释: s2 包含 s1 的排列之一 (“ba”).
示例2:
输入: s1= “ab” s2 = “eidboaoo”
输出: False

   private static boolean checkInclusion1_567(String s1, String s2) {
        if (s1.length() > s2.length()) {
            return false;
        }
        for (int i = 0; i < s2.length() - s1.length() + 1; i++) {
            String substring = s2.substring(i, s1.length() + i);
            int[] index = new int[128];
            //通过数组判断字符个数是否一致
            for (int j = 0; j < s1.length(); j++) {
                index[s1.charAt(j)]--;
                index[substring.charAt(j)]++;
            }
            boolean flag = true;
            for (int j = 0; j < index.length; j++) {
                if (index[j] != 0) {
                    flag = false;
                }

            }
            if (flag) {
                return true;
            }
        }

        return false;
    }

4. 找到字符串中所有字母异位词

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。
字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。
说明：
字母异位词指字母相同，但排列不同的字符串。
不考虑答案输出的顺序。
示例 1:
输入:
s: “cbaebabacd” p: “abc”
输出:
[0, 6]
解释:
起始索引等于 0 的子串是 “cba”, 它是 “abc” 的字母异位词。
起始索引等于 6 的子串是 “bac”, 它是 “abc” 的字母异位词。
示例 2:
输入:
s: “abab” p: “ab”
输出:
[0, 1, 2]
解释:
起始索引等于 0 的子串是 “ab”, 它是 “ab” 的字母异位词。
起始索引等于 1 的子串是 “ba”, 它是 “ab” 的字母异位词。
起始索引等于 2 的子串是 “ab”, 它是 “ab” 的字母异位词。

    private List<Integer> findAnagrams1_438(String s, String p) {
        List<Integer> list = new ArrayList<>();
        if (p.length() > s.length()) {
            return list;
        }
        for (int i = 0; i < s.length() - p.length() + 1; i++) {
            String substring = s.substring(i, p.length() + i);
            int[] index = new int[128];
            //通过数组判断字符个数是否一致
            for (int j = 0; j < p.length(); j++) {
                index[p.charAt(j)]--;
                index[substring.charAt(j)]++;
            }
            boolean flag = true;
            for (int j = 0; j < index.length; j++) {
                if (index[j] != 0) {
                    flag = false;
                }

            }
            if (flag) {
                list.add(i);
            }
        }

        return list;
    }

5. 滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。
进阶：
你能在线性时间复杂度内解决此题吗？
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:
滑动窗口的位置 最大值

---

[1 3 -1] -3 5 3 6 7 3
1 [3 -1 -3] 5 3 6 7 3
1 3 [-1 -3 5] 3 6 7 5
1 3 -1 [-3 5 3] 6 7 5
1 3 -1 -3 [5 3 6] 7 6
1 3 -1 -3 5 [3 6 7] 7

    private static int[] maxSlidingWindow1_239(int[] nums, int k) {
        if (nums == null || nums.length == 0 || k <= 0) {
            return null;
        }
        if (nums.length < k) {
            List<Integer> list = new ArrayList<>(1);
            int[] arr = new int[1];
            arr[0] = getMaxNum(nums, 0, nums.length - 1);
            return arr;
        }

        int arr[] = new int[nums.length - k + 1];
        List<Integer> list = new ArrayList<>(nums.length - k + 1);
        for (int i = 0; i < nums.length - k + 1; i++) {
            arr[i] = getMaxNum(nums, i, i + k - 1);
        }

        return arr;

    }

    private static int getMaxNum(int[] nums, int start, int end) {
        int max = nums[start];
        for (int i = start; i <= end; i++) {
            max = Math.max(nums[i], max);
        }
        return max;
    }