力扣高频|算法面试题汇总(四）：堆、栈与队列

力扣高频|算法面试题汇总(四）：堆、栈与队列

力扣链接
目录：

1.最小栈
2.数组中的第K个最大元素
3.数据流的中位数
4.有序矩阵中第K小的元素
5.前 K 个高频元素
6.滑动窗口最大值
7.基本计算器 II
8.扁平化嵌套列表迭代器
9.逆波兰表达式求值

1.最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
示例:
输入：
[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]
解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
提示：
pop、top 和 getMin 操作总是在非空栈上调用。

C++

class MinStack {
   
private:
    vector<int> nums;
public:
    /** initialize your data structure here. */
    MinStack() {
   

    }
    
    void push(int x) {
   

        nums.push_back(x);
    }
    
    void pop() {
   
        nums.pop_back();
    }
    
    int top() {
   
        return nums[nums.size() - 1];
    }
    
    int getMin() {
   
        int min = nums[0];
        for(auto num : nums){
   
            if(num < min)
                min = num;
        }
        return min;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

Python

class MinStack:
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.nums = []
    def push(self, x: int) -> None:
        self.nums.append(x)
    def pop(self) -> None:
        self.nums.pop()
    def top(self) -> int:
        return self.nums[len(self.nums) - 1]
    def getMin(self) -> int:
        min = self.nums[0]
        for num in self.nums:
            if num < min:
                min = num
        return min
# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(x)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

2.数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4
说明:
你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

思路1：
排序后查找。
使用默认排序算法的复杂度：算法的时间复杂度为 $O (N l o g N)$ ，空间复杂度为 $O (1)$ 。
C++

class Solution {
   
public:
    int findKthLargest(vector<int>& nums, int k) {
   
        sort(nums.begin(), nums.end());
        return nums[nums.size() - k];
    }
};

Python

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        nums = sorted(nums)
        return nums[len(nums) - k]

思路2:
参考官方思路，使用大顶堆，保留k个最大的数。
向大小为 k 的堆中添加元素的时间复杂度为 $O (l o g k)$ ，我们将重复该操作 N 次，故总时间复杂度为 {O}(N \log k)O(Nlogk)。
在 Python 的 heapq 库中有一个 nlargest 方法，具有同样的时间复杂度，能将代码简化到只有一行。
C++

class Solution {
   
public:
    int findKthLargest(vector<int>& nums, int k) {
   
        priority_queue<int,vector<int>,greater<int>> q;
        for(auto it:nums){
   
            q.push(it);
            if(q.size()>k) q.pop();
        }
        return q.top();
    }
};

Python

class Solution:
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        return heapq.nlargest(k, nums)[-1]

3.数据流的中位数

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。
例如，
[2,3,4] 的中位数是 3
[2,3] 的中位数是 (2 + 3) / 2 = 2.5
设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例：
addNum(1)
addNum(2)
findMedian() -> 1.5
addNum(3)
findMedian() -> 2
进阶:
如果数据流中所有整数都在 0 到 100 范围内，你将如何优化你的算法？
如果数据流中 99% 的整数都在 0 到 100 范围内，你将如何优化你的算法？

思路1：
暴力法，每次获取中位数时就进行排序获取，超时。
思路2：
使用最大堆和最小堆，参考剑指offer：数据流中的中位数
C++

class MedianFinder {
   
private:
    // 最大堆
    vector<int> maxheap;
    // 最小堆
    vector<int> minheap;
public:
    /** initialize your data structure here. */
    MedianFinder() {
   
        
    }
    void addNum(int num) {
   
       int size = maxheap.size() + minheap.size();
        // 如果当前数目是偶数个，默认把num放进最小堆
        if((size & 1) == 0){
   
            int temp = num;
            //如果最大堆不为空，且输入的数字小于最大堆的最大值
            if(!maxheap.empty() && num < maxheap[0]){
   
                // 把最大的数字拿出来
                temp = maxheap[0];
                // 再把数字放进最大堆
                maxheap[0] = num;
                // 重新生成最大堆
                make_heap(maxheap.begin(), maxheap.end());
            }
            // 把元素放进最小堆
            minheap.push_back(temp);
            // 重新生成最小堆
            push_heap(minheap.begin(), minheap.end(), greater<int>());
        }else{
   // 如果当前数目是奇数个，默认把num放进最大堆
            int temp = num;
            // 如果最小堆不为空，且输入的数字大于最小堆的最小值
            if(!minheap.empty() && num > minheap[0]){
   
                temp = minheap[0]; // 把最小的数字拿出来
                minheap[0] = num; // 把输入的数字放进最小堆
                make_heap(minheap.begin(), minheap.end(), greater<int>());
            }
            // 把元素放进最大堆
            maxheap.push_back(temp);
            // 重新生成最大堆
            push_heap(maxheap.begin(), maxheap.end());
        }
    }
    
    double findMedian() {
   
        int size = maxheap.size() + minheap.size();
        double res;
        if(size