单调队列，窗口最大值

最新推荐文章于 2025-07-25 00:44:40 发布

原创最新推荐文章于 2025-07-25 00:44:40 发布 · 349 阅读

0 ·

CC 4.0 BY-SA版权

算法其他专栏收录该内容

6 篇文章

订阅专栏

本文探讨如何高效地解决滑动窗口最大值的问题，对比暴力解法，提出使用单调队列优化。通过一个双向队列结构，每次更新时删除左侧不再可能的最大值，并维护右侧可能的最大值。参考了两篇优质博客，详细解释了递增栈的概念，并分享了作者在实现过程中的思考和调试经验。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题

有一个整型数组arr和一个大小为w的窗口从数组的最左边滑到最右边，窗口每次向右边滑一个位置。

例如，数组为[4,3,1,5,4,3,7,5]，窗口大小为5时:

[4 3 1 5 4] 3 7 5 　max = 5

4 [3 1 5 4 3] 7 5 　max = 5

4 3 [1 5 4 3 7] 5 　max = 7

4 3 1 [5 4 3 7 5] 　max = 7

即窗口最大值数组为 result = {5, 5,7,7}

解一：暴力解法（几乎是比那里一遍吧，，）

import java.util.Arrays;

class Main{
    public static void main(String[] args) {
        int[] arrr = {4,3,1,5,4,3,7,5};
        int wr = 5;
        getMaxWindow(arrr,wr);

    }
    public static int[] getMaxWindow(int [] arr,int w){ //w是窗口的大小
        if(w<1 || arr==null || arr.length<w){
            return null;
        }
        int[] result  = new int[arr.length-w+1];

        for(int i= 0;i<arr.length-w+1;i++){
            int max = arr[i];
            for(int j = i;j<i+w;j++){
                if(arr[j]>max) {
                    max = arr[j];
                }
            }result[i] = max; // 已经是遍历一遍了，，但这，，，属于暴力，啊哦

        }
//        for(int i =0;i<result.length;i++){
//            System.out.println(arr[i]);
//        }
    //    System.out.println(result);               //上面两种打印方法都不行
        System.out.println(Arrays.toString(result));
        return result;


    }
}

突然知道java打印一维数组的方式是 System.out.println(Arrays.toString(result));

解二：使用双向队列结构

这里用linkedlist不用ｑｕｅｕｅ？？？因为ｑｕｅｕｅ是一个接口，不能实例话，Linkedlist才是类！！！

Deque<Integer> temp = new ArrayDeque<Integer>();用这个也可以

优化使用双向队列结构，，每次更新左边一定不会再出现最大值，右边可能会出现最大值，那就把右边单独做成双向队列结构，队列底放最大值，出现最大的值队列内前面的数字就清空，把最大的数放在最下面

import java.util.Arrays;
import java.util.LinkedList;

class Main{
    public static void main(String[] args) {
        int[] arrr = {4,3,1,5,4,3,7,5};
        int wr = 5;
        getMaxWindow(arrr,wr);

    }
    public static int[] getMaxWindow(int[] arr,int w){
        if (w < 1 || arr == null || arr.length < w) {
            return null;
        }
        int index =0;
        int[] result = new int[arr.length - w + 1];
        LinkedList<Integer> temp = new LinkedList<>();
        for(int i=0;i<arr.length;i++){//队列不为空而且这个数字比队列首要大的话
            while (!temp.isEmpty() &&arr[temp.peekLast()]<=arr[i]){
                temp.pollLast(); // 把队尾元素弹出
            }
            temp.addLast(i); //把这个元素放到队尾
            if(temp.peekFirst() == i -w){
                temp.pollFirst(); //如果队首元素不再窗口范围内，则弹出
            }
            //经过上面的，放在队列首端的就一定是最大的，把他副那个在result数组中
            if(i>=w-1){　　//这里，，我真的不知道为啥，我觉得减的应该是下标，但为什么，，，
                result[index++] = arr[temp.peekFirst()];
            }

        }
        System.out.println(Arrays.toString(result));
        return result;
    }
}

参考连接：https://mp.weixin.qq.com/s?__biz=MzUxNzg0MDc1Mg==&mid=2247484791&idx=1&sn=555ecf7315a549de05555e5009678c8b&chksm=f9934f68cee4c67eeecd09a63f7212971fcb3e14eaa132c46b033085f562e5051e5a7300ef14&mpshare=1&scene=1&srcid=11223Ix5YaQq2uaQL8Cuuj1U&pass_ticket=HLQimp5JG%2FS4LmDj1T4c4zjfWzohxzdRNH8F09mlG0d9PyFHCMaRgbxjOczSnlYG#rd

２、

https://blog.youkuaiyun.com/zjkc050818/article/details/74114972参照这两篇博客，，原文写的炒鸡好呀

重点句子：

我们有一种更好的思路就是通过递增栈。所谓的递增栈，就是栈中只存放递增序列。

经过好长时间的思索，终于写出了代码，这个是我刚开始的代码，有好多不严谨

import java.util.Stack;

class Kruskal{
    public static void main(String[] args) {
        int arr[] = {2,1,5,6,2,3};
        System.out.println(f(arr));
    }
    static int f(int[] arr){
        if (arr == null || arr.length < 1) {
            return 0;
        }
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(0);
        int cnt = 0;
        int maxs = 0;
        for(int i = 1;i<arr.length;i++){
            int nochange = stack.peek();//这个，，，我还定义了一个变量表示最开始的，起始不用哎，
            if(arr[i]>stack.peek()){
                int t = stack.peek();
                stack.pop();
                cnt = nochange - t+1;
                maxs = Math.max(maxs,arr[t]*cnt);

            }else { //这里ｅｌｓｅ不对，怎么可能有的入栈，有的不入栈？？只分一个有的入之前清栈，有的不清而已
                stack.push(i);
            }
        }
        int nochange2 =stack.peek();
        while (stack!=null){
            int t2 = stack.peek();
            stack.pop();
            cnt = nochange2 - t2+1;
            maxs = Math.max(maxs,arr[t2]*cnt);

        }
        return maxs;
    }
}

我的妈呀，，这个代码真的是调了我好久好久，终于对了

import java.util.Stack;

class Kruskal{
    public static void main(String[] args) {
        int arr[] = {2,1,5,6,2,3};
        System.out.println(f(arr));
    }
    static int f(int[] arr){
        if (arr == null || arr.length < 1) {
            return 0;
        }
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(-1); //这样可以预防emptyStackException的错误

        int maxs = 0;
        for(int i = 0;i<arr.length;i++){
    //        int nochange = stack.peek();//这个不能在这里放，因为他会一直动，放到里面
            while (stack.peek()!=-1 && arr[i]<arr[stack.peek()]){ //这儿对栈操作前判断一下就可以预防空栈错误了

                int t = stack.pop();
               //可以跟ｉ联系起来，因为进了这一步，就代表这个ｉ要小，要弹出前面的了，栈最顶元素是ｉ－１
                maxs = Math.max(maxs,arr[t]*(i-1-stack.peek()));

            }//这里ｅｌｓｅ不对，怎么可能有的入栈，有的不入栈？？只分一个有的入之前清栈，有的不清而已
            stack.push(i);

        }
//        int nochange2 =stack.peek();
        while (stack.peek()!=-1){
//            int t2 = stack.peek();
//            stack.pop();
//            cnt = nochange2 - t2+1;
//            maxs = Math.max(maxs,arr[t2]*cnt);
            int top = stack.pop();
            maxs = Math.max(maxs,(arr.length-1-stack.peek())*arr[top]);
        }
        return maxs;
    }
}