滑动窗口的最大值

function maxInWindows(num, size)
{
    // write code here
    let que = []//定义一个存最大值下标的双头队列，队首为最大值
    let res = []//存窗口最大值的数组
    const n = num.length
    for(let i =0;i<n;i++){
        if(i-que[0] >= size){//当维护的最大值不在窗口范围内时，将队首出队
            que.shift()
        }
        while(que.length>0 && num[que[0]]<=num[i]){//当新入队的值为最大值时，将队列清空
            que.shift()
        }
        while(que.length>0 && num[que[que.length-1]]<=num[i]){//当新入队的值比可能成为最大值的值大时，将比此值小的值出队
            que.pop()
        }
        que.push(i)//将此值入队
        
        if(i>=size-1){//将移动窗口中维护的最大值加入结果数组中
            res.push(num[que[0]])
        }
    }
    return res
}
module.exports = {
    maxInWindows : maxInWindows
};

function maxInWindows(num, size) {
    // write code here
    if (!size || !num.length) return []

    let start = 0, res = []

    while (start + size <= num.length) {
        res.push(Math.max(...num.slice(start, start + size)))
        start++
    }

    return res
}

function maxInWindows(num, size)
{
    // write code here
    let res = [];
    if(num.length<size||size==0){
        return res;
    }
    
    let pro = num;
    let len = pro.length;
    let sum = 0,list=[];
    
    while(len-size+1){
        let arr = pro.slice(0,size);
        pro = pro.slice(1,num.length);
        arr.forEach(item=>{
            sum+=item;
        })
        res.push(Math.max(...arr))//窗口的最大值
        list.push(sum);//求和
        len--;
    }
    //console.log(res);
    let max = 0;
    max = Math.max(...list);//取最大和
    //console.log(max);
    return res;
}
module.exports = {
    maxInWindows : maxInWindows
};

function maxInWindows(num, size)
{
    let k = size;
    if (k * num.length === 0) return [];

    let slidBar = [];
    for (let i = 0; i < (num.length - k + 1); i++) {
    let max = 0;
    for (let j = i; j < i + k; j++) {
        max = Math.max(max, num[j]);
    }
        slidBar.push(max)
    }
    return slidBar;
}


function maxInWindows(num, size){
    let k = size;
    if (k * num.length === 0) return [];
    const deque = [], res = [];
    for (let i = 0; i < num.length; i++) {
        while (deque.length && num[i] > deque[deque.length - 1]){
            deque.pop()
        }
        deque.push(num[i]);
        if (i >= k - 1) {
            res.push(deque[0]);
            if (num[i - k + 1] === deque[0]) deque.shift();
        }
    }
    return res;
};

function maxInWindows(num, size)
{
    if(size === 0){
        return [];
    }
    let arr = [];
    while(num.length >= size){
        arr.push(num.slice(0, size));
        num.shift();
    }
    let maxArr = [];
    arr.forEach(i => {
        maxArr.push(i.sort((a, b) => b - a)[0]);
    })
    return maxArr;
}

方法一：

function maxInWindows(num, size)
{
    const res = [];
    if (size > num.length || size <= 0) return res;
    for (let i = 0; i <= num.length - size; i++) {
        res.push(Math.max(...num.slice(i, i + size)));
    }
    return res;
}

方法二：

class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class Deque {
    constructor() {
        this.head = new TreeNode(0);
        this.tail = new TreeNode(0);
        this.head.right = this.tail;
        this.tail.left = this.head;
    }
    empty() {
        return this.head.right === this.tail;
    }
    front() {
        if (this.empty()) return null;
        return this.head.right.val;
    }
    pop_front() {
        const node = this.head.right;
        this.head.right = node.right;
        node.right.left = this.head;
        node.left = null;
        node.right = null;
        return node;
    }
    back() {
        if (this.empty()) return null;
        return this.tail.left.val;
    }
    push_back(value) {
        const node = new TreeNode(value);
        node.left = this.tail.left;
        node.right = this.tail;
        node.left.right = node;
        this.tail.left = node;
    }
    pop_back() {
        const node = this.tail.left;
        node.left.right = this.tail;
        this.tail.left = node.left;
        node.left = null;
        node.right = null;
        return node;
    }
}


function maxInWindows(num, size)
{
    const ret = [];
    if (!num || size < 1 || num.length < size) return ret;
    const dq = new Deque();
    for (let i = 0; i < num.length; i++) {
        while (!dq.empty() && num[dq.back()] < num[i]) {
            dq.pop_back();
        }
        dq.push_back(i);
        if (dq.front() + size <= i) dq.pop_front();
        if (i + 1 >= size) ret.push(num[dq.front()]);
    }
    return ret;
}

function maxInWindows(num, size)
{
    // write code here
    if(!num){
        return null;
    }
    var len = num.length;
    var arr = [];
    if(size > len || size <= 0){
        return arr;
    }
    if(size == 1){
        return num;
    }
    if(size == len){
        //注意这里用Math.max()的时候，如果直接传的是数组名，要在前面加...符号，不然不成功
        arr.push(Math.max(...num));
        return arr;
    }
    for(var i = 0;i < len - size + 1;i++){
        var num1 = [];
        num1 = num.slice(i,i+size);
        arr.push(Math.max(...num1));
    }
    return arr;
}
if好像写的有点多~

function maxInWindows(num, size)
{
    // write code here
    //暴力法：
    if(!num.length ||size == 0) return []
    let res = []
    for(let i = 0;i<num.length-size+1;i++){
        let temp = num.slice(i,i+size)
        let max = Math.max(...temp)
        res.push(max)
    }
    return res
    
}

function maxInWindows(num, size)
{

    // 双端队列中保存的是元素下标，方便判断元素是否在当前滑动窗口中
        //  双端队列头元素对应的数字，就是当前滑动窗口的最大值
       //  双端队列头尾出入元素的时间复杂度是O(1)
    iif(!num.length || size == 0) return []
    let res=[];
    //这个队列储存索引
    let que=[];
    for(let i=0;i<num.length;i++){
        //确保队列中索引在滑动窗口内
        while(que.length>0 && que[0]<=i-size){//当当前窗口移出队首元素所在的位置，即队首元素坐标对应的num不在窗口中，需要弹出
            que.shift();
        }
        //确保该队列为单调队列
        while(que.length>0 && num[que[que.length-1]]<num[i]){//从后面依次弹出队列中比当前num值小的元素，同时也能保证队列首元素为当前窗口最大值下标
            que.pop();
        }
        que.push(i);//把每次滑动的num下标加入队列
        if(i>=size-1) res.push(num[que[0]]); //当滑动窗口首地址i大于等于size时才开始写入窗口最大值
    }
    return res;


}

//滑动窗口双指针
function maxInWindows(num, window)
{
    if(num.length==0||window==0||window>num.length){
        return [];
    }
    var list = [];
    var left=0;
    var right = window - 1;
    while(right<num.length){
        //获得本轮的窗口（数组）
        var windowArr = num.slice(left,right+1);
        //找到本轮的窗口的最大值
        var max = Math.max(...windowArr);
        //存入结果数组中
        list.push(max);
        //右移窗口进入下一次比较
        right++;
        left++;
    } 
   return list;
}