剑指offer 第27天栈与队列（困难）C++题解

杨小木木

于 2022-11-22 20:54:34 发布

阅读量179

点赞数 1

分类专栏：剑指offer 文章标签： leetcode 算法职场和发展 c++ 数据结构

本文链接：https://blog.csdn.net/qq_39858171/article/details/127980237

版权

剑指offer 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

一、滑动窗口最大值

剑指 Offer 59 - I. 滑动窗口的最大值https://leetcode.cn/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/

给定一个数组 nums 和滑动窗口的大小 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

提示：

你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ nums.length。

注意：本题与主站 239 题相同：https://leetcode-cn.com/problems/sliding-window-maximum/

解题思路：

1.暴力解法将区间k中的最大值找到同时遍历整个数组，时间复杂度为O（Nk）。有更优的解法。

2.利用单调队列可以将每次获取区间k内最大值的时间复杂度降到O（1）。总体的时间复杂度为O（N）。

具体细节：

1.初始化双端队列 deque ，结果列表 res ，数组长度 n ；

2.滑动窗口左边界范围 i∈[1−k,n−k] ，右边界范围 j∈[0,n−1] ；

3.若 i > 0 且队首元素 deque[0] == 被删除元素 nums[i - 1] ：则队首元素出队；

4.删除 deque 内所有 < nums[j] 的元素，以保持 deque 递减；将 nums[j] 添加至 deque 尾部；

5.若已形成窗口（即 i≥0 ）：将窗口最大值（即队首元素 deque[0] ）添加至列表 res。

复杂度分析：

1.时间复杂度：O（N）。

2.空间复杂度：O（k）。

代码实现：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        deque<int> dq;
        int n = nums.size();
        vector<int> res;
        if (n == 0) return res;
        for (int i = 0; i < k; i++) {
            while (!dq.empty() && nums[i] > nums[dq.back()]) dq.pop_back();
            dq.push_back(i);
        }
        res.push_back(nums[dq.front()]);
        for (int i = k; i < n; i++) {
            while (!dq.empty() && nums[i] > nums[dq.back()]) dq.pop_back();
            dq.push_back(i);
            while (dq.front() <= i - k) dq.pop_front();
            res.push_back(nums[dq.front()]);
        } 
        return res;
    }
};

二、队列的最大值

面试题59 - II. 队列的最大值https://leetcode.cn/problems/dui-lie-de-zui-da-zhi-lcof/

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。

若队列为空，pop_front 和 max_value 需要返回 -1

示例 1：

输入:
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]

示例 2：

输入:
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]

限制：

1 <= push_back,pop_front,max_value的总操作数 <= 10000
1 <= value <= 10^5

解题思路：

1.普通队列需要遍历整个队列找到最大值，时间复杂度为O（N），要想时间复杂度降为O（1），可以用空间换时间，构建一个辅助队列来记录最大值。

2.辅助队列随着入队和出队操作实时更新，这样队列最大元素就始终对应辅助队列的首元素，实现了获取最大值O(1) 时间复杂度。

具体细节：

1.初始化队列 queue ，双向队列 deque ；

2.返回最大值时直接返回双向队列的队首元素；

3.入队：将元素 value 入队 queue ；将双向队列中队尾所有小于value 的元素弹出（以保持 deque 非单调递减），并将元素 value 入队 deque ；

4.出队 pop_front() ：将 queue 首元素出队；若 deque 首元素和 queue 首元素相等，则将 deque 首元素出队（以保持两队列元素一致）。

复杂度分析：

1.时间复杂度：平均复杂度为O（1）。

2.空间复杂度：需额外的辅助队列O（N）。

代码实现：

class MaxQueue {
public:
    queue<int> data;
    deque<int> max;
    MaxQueue() {

    }
    
    int max_value() {
        if (!max.empty()) return max.front();
        else return -1;
    }
    
    void push_back(int value) {
        data.push(value);
        if (max.empty()) max.push_back(value);
        else {
            while (!max.empty() && value > max.back()) max.pop_back();
            max.push_back(value);
        }
       
    }
    
    int pop_front() {
        if (data.empty()) return -1;
        int temp = data.front();
        data.pop();
        if (max.front() == temp) max.pop_front();
        return temp;
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */