数据结构与算法---栈---最小栈、滑动窗口最大值

最新推荐文章于 2021-11-18 10:28:25 发布

原创最新推荐文章于 2021-11-18 10:28:25 发布 · 297 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

57 篇文章

订阅专栏

栈

栈的特点是：先进后出，后进先出
利用这个特点，可以解决一些对称有关的问题

上一题的回文链表，是否能使用栈解决呢？

首先，还是需要找到中间节点3
然后，创建一个栈，一个一个压栈，当遇到中间节点3的时候，不入栈，进下一个
然后，进行出栈跟新的比较，判断是否相等，直到栈空

这思路不错

在这里插入图片描述

最小栈

155. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。

思路

题目意思就是，设计一个栈，可以使用getMin()在常数时间内找到最小元素

常数时间，指的是空间复杂度O(1)

假如数据为3 4 2 5 2 1
设计两个栈
栈A是正常栈，栈B只存储最小元素
3入栈A，判断栈是空，那么同时将3入栈B
4入栈A，4比B栈顶元素3大，则在B中入栈一个3
2入栈A，2比B栈顶元素3小，则在B中入栈一个2
5入栈A，5比B栈顶元素2大，则在B中入栈一个2
2入栈A，2比B栈顶元素2相等，则在B中入栈一个2（新的或者B栈顶元素都可以）
1入栈A，1比B栈顶元素2小，则在B中入栈一个1

在使用getMin()的时候，对B栈出栈即可

class MinStack {

    //创建两个普通栈
    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int x) {
        stack.push(x);

        if(minStack.isEmpty()){
            minStack.push(x);
        }else{
            if(x > minStack.peek()){
                minStack.push(minStack.peek());
            }else{
                minStack.push(x);
            }
        }
        
    }
    
    public void pop() {
        stack.pop();
        minStack.pop();
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

队列

队列的特点是：先进先出，后进后出
利用这个特点，可以解决一些顺序有关的问题

双端队列（Deque）

deque 是：double ended queue

双端队列是能在头尾两端添加、删除的队列

啥？？？那不就成了普通链表、或者说是普通数组？
这样就没有了先进先出的特性，还能叫队列？

滑动窗口最大值

239.滑动窗口最大值

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

进阶：你能在线性时间复杂度内解决此题吗？

示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7]
解释:

sequenceDiagram
  滑动窗口的位置                最大值
---------------               -----
[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

提示：

1 <= nums.length <= 10^5
-10^4 <= nums[i] <= 10^4
1 <= k <= nums.length

首先，可以确定的是返回数组的长度大小：
输入的数组长度nums.length - (k - 1)

思路1

使用暴力法

每k个找一次，然后窗口右移1，再次找最大值

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //边界条件
        if(nums == null || nums.length == 0 || k < 1) return new int[]{};
        if(k == 1) return nums;

        //新建一个返回数组
        int[] resultArray = new int[nums.length - (k - 1)];

        for(int i = 0; i < nums.length - (k - 1); i++)
        {
            int max = nums[i];
            for(int j = 0; j < k; j++)
            {
                if(max < nums[i + j])
                {
                    max = nums[i + j];
                }
            }
            resultArray[i] = max;
        }
        return resultArray;
    }
}

时间复杂度：O(n*k)
在这里插入图片描述没有通过LeetCode的时间限制。

思路2

上面的时间之所以没有通过，在于有很多的重复计算，那，能否在第一个计算的时候，将最大值保存下来，当比较下一个窗口的时候，
首先判断前一个最大值是否在新的窗口内：
如果最大值在新的窗口内，拿最大值与新加入的值做比较，取最大的做新的最大值；
如果最大值不在新的窗口内，再进行k次比较，找到最大值；

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if(nums == null || nums.length == 0 || k < 1) return new int[0];
        if(k == 1) return nums;

        int[] maxArray = new int[nums.length - (k - 1)];
        int maxIndex = 0;

        //求出第一个窗口中的最大值
        for(int i = 1; i < k; i++)
        {
            if(nums[maxIndex] < nums[i]) 
            {
                maxIndex = i;
            }
        }

        //求出最大值
        for(int li = 0; li < maxArray.length; li++)
        {
            int ri = li + k - 1;
            if(maxIndex >= li && maxIndex <= ri)//在窗口内
            {
                if(nums[ri] > nums[maxIndex])
                {
                    maxIndex = ri;
                }
            }else{
                maxIndex = li;
                for(int i = li + 1; i <= ri; i++)
                {
                    if(nums[maxIndex] < nums[i]) 
                    {   
                        maxIndex = i;
                    }
                }
            }
            maxArray[li] = nums[maxIndex];
        }
        return maxArray;

    }
}

时间复杂度分析

最坏情况：每次最大值都不能使用，需要每次遍历一遍新的窗口，那么时间复杂度与上面暴力法时间复杂一样，都是O(n*k)

最好情况：每次最大值都能使用（不现实，一个最大值不能从头用到尾）
那么，最好的情况是，新的最大值一直出现在新窗口的最后面

上述方法，可以在最大值在有效区间内直接取，但是，如果最大值不在有效区间，就得比较了。
那么，能否使得最大值不在有效区间，也能不通过比较，一下找到新的最大值呢？
能否存储第二最大值，第三最大值，当第一最大值不符的时候，取第二最大值。
这就需要借助队列了，因此，队列具有顺序的特点，这也就是思路3

思路3

使用双端队列
建立一个双端队列，队列满足以下条件：

队列里面存放的是索引，因为使用索引可以拿到值，一个字段可以存两个值
队列中的元素从头到尾对应的元素值是逐渐减少的

首先，第一个值从队尾先入队，然后入队新值；
如果新值比队尾元素大，则将队列中比新值小的元素一一删除，直至遇到队列中比新值大的元素停止（也可能队列被清空了）
如果新值比队头元素小，则将新值从队尾入队

新值入队后，检查队头的元素合法性（是否在窗口范围内）
如果在合理范围内，则将队头元素copy一个到返回数组中；
如果不在合理范围内，则看队列下一个元素是否在合理范围内。

转化为伪代码：

如果nums[i] >= nums[队尾]，则不断删除队尾，直到 nums[i] < nums[队尾]为止
将i加入队尾
如果w >= 0
3.1 如果队头失效，就移除队头（如果队头 < w，就代表失效）
3.2 设置w窗口的最大值为 nums[队头]


class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        //边界条件
        if(nums == null || nums.length == 0 || k < 1) return new int[]{};
        if(k == 1) return nums;

        //新建一个返回数组
        int[] resultArray = new int[nums.length - (k - 1)];

        //创建双端队列
        Deque<Integer> deque = new LinkedList<Integer>();

        for(int i = 0; i < nums.length; i++)
        {
            while(!deque.isEmpty())
            {
                if(nums[i] >= nums[deque.peekLast()])
                {
                    //出队
                    deque.removeLast();
                }else{
                    break;
                }
            }

            deque.addLast(i);

            int w = i - (k - 1);
            if(w < 0) continue;//w不合法

            if(deque.peekFirst() < w)//代表队头失效
            {
                deque.removeFirst();
            }
            resultArray[w] = nums[deque.peekFirst()];
        }
        return resultArray;
    }
}