JS：滑动窗口算法 （下集）

上集的两道题目，分开两集的目的是，尽可能自己手写一遍模板。

438. 找到字符串中所有字母异位词 （中等）

其实就是在567. 字符串的排列的基础上，找到 S 中所有 T 的排列，返回它们的起始索引。

/**
 * @param {string} s
 * @param {string} p
 * @return {number[]}
 */
var findAnagrams = function(s, p) {
    let need = {}, window = {};
    for (let c of p) need[c] = (need[c] || 0) + 1;
    let left = right = count = 0, ans = [];
    let maxlen = p.length, target = Object.keys(need).length, len=s.length;

    while(right < len){
        let c = s[right]
        right++
        if (need[c]) {
            window[c] = (window[c] || 0) + 1
            if (need[c] == window[c]) count++;
        }
        while(right - left == maxlen) {
            if (count == target) ans.push(left);
            let c = s[left]
            left++
            if (need[c]) {
                if (need[c] == window[c]) count--;
                window[c]--;
            }
        }
    }
    return ans;
};

3. 无重复字符的最长子串 （中等）

提示：这个题终于有了点新意，不是一套框架就出答案，不过反而更简单了，稍微改一改框架就行了。因为只给出一个字符串，只需window来统计窗口内的字符。

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function(s) {
    let window = {};
    let left = right = ans = 0, len = s.length;
    while(right < len) {
        let c = s[right]
        right++
        window[c] = (window[c] || 0) + 1
        while(window[c] > 1) {
            let d = s[left]
            left++
            window[d]--
        }
        ans = Math.max(ans, right-left)
    }
    return ans;
};

239. 滑动窗口的最大值 （困难）

该题不是用对象统计，而是使⽤⼀个队列充当不断滑动的窗⼝，每次滑动记录其中的最⼤值。


这个技术有点印象，以前有运用过。

官方代码，如果记录下标执行时间很短：

var maxSlidingWindow = function (nums, k) {
  // 队列数组（存放的是元素下标，为了取值方便）
  const q = [];
  // 结果数组
  const ans = [];
  for (let i = 0; i < nums.length; i++) {
    // 若队列不为空，且当前元素大于等于队尾所存下标的元素，则弹出队尾
    while (q.length && nums[i] >= nums[q[q.length - 1]]) {
      q.pop();
    }
    // 入队当前元素下标
    q.push(i);
    // 判断当前最大值（即队首元素）是否在窗口中，若不在便将其出队
    while (q[0] <= i - k) {
      q.shift();
    }
    // 当达到窗口大小时便开始向结果中添加数据
    if (i >= k - 1) ans.push(nums[q[0]]);
  }
  return ans;
};

作者：carlsun-2
链接：https://leetcode-cn.com/problems/sliding-window-maximum/solution/dai-ma-sui-xiang-lu-dai-ni-gao-ding-zhan-y82r/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

而我按照模板，滑动窗口模式，却是30倍时间，未解之谜：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSlidingWindow = function(nums, k) {
    let ans = [], window = [];
    let left = right = 0, len = nums.length;
    while (right < len) {
        let c = nums[right]
        right++
        // 插入队列
        while (window.length && c > window[window.length-1]) window.pop();
        window.push(c)
        while (right - left == k) {
            ans.push(window[0])
            let d = nums[left]
            left++
            if (d == window[0]) window.shift()
        }
    }
    return ans;
};

通过逐行分析，十几次的提交，发现了原因，使用官方代码，将大于等于，改成大于，用时竟然相差这么多。
while (q.length && nums[i] >= nums[q[q.length - 1]])

而我的方法，是不能设置成大于等于的，因为如果窗口有两个相同的最大值，大于等于情况下，window只记录一个。

如果不使用记录下标的方式，又减少执行时间，那就验证窗口内有没有相同的最大值。（如果不是困难题目，我也不细究了。。。）

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var maxSlidingWindow = function(nums, k) {
    let ans = [], window = [];
    let left = right = 0, len = nums.length;
    while (right < len) {
        let c = nums[right]
        right++
        // 插入队列
        while (window.length && c >= window[window.length-1]) window.pop();
        window.push(c)
        while (right - left == k) {
            ans.push(window[0])
            let d = nums[left]
            left++
            if (d == window[0]) {
                let mark = 1
                for (let i=left; i<right; i++){
                    if (nums[i] == d) {mark = 0; break;}
                }
                if(mark) window.shift()
            }
        }
    }
    return ans;
};