LeetCode：栈、队列、堆 问题解决方案集合（教程+Python代码）

目录

预备知识：

例1:LeetCode225. 用队列实现栈(easy)

例2:LeetCode232. 用栈实现队列(easy)

例3:LeetCode155. 最小栈(easy)

例4:LeetCode215. 数组中的第K个最大元素(easy)

例5:LeetCode295. 数据流的中位数（hard)

---

 

 

预备知识：

栈Stack：（先进先出）

队列Queue：（先进后出）

堆：具体Python实现讲解https://blog.csdn.net/qq_35883464/article/details/99410423

 

例1:LeetCode225. 用队列实现栈(easy)

使用队列实现栈的下列操作：

push(x) -- 元素 x 入栈
pop() -- 移除栈顶元素
top() -- 获取栈顶元素
empty() -- 返回栈是否为空
注意:

你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。
你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。
你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。

思路：

代码：

class MyStack:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        from collections import deque
        self.q = deque()
        
    def push(self, x: int) -> None:
        self.q.append(x)
        for _ in range(len(self.q)-1):
            self.q.append(self.q.popleft())

    def pop(self) -> int:
        return self.q.popleft()

    def top(self) -> int:
        """
        Get the top element.
        """
        return self.q[0]

    def empty(self) -> bool:
        """
        Returns whether the stack is empty.
        """
        return not len(self.q)

 

例2:LeetCode232. 用栈实现队列(easy)

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。
示例:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);  
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false

说明:

你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。

思路：

思路：

class MyQueue:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stack1 = []
        self.stack2 = []

    def push(self, x: int) -> None:
        """
        Push element x to the back of queue.
        """
        if self.stack1 == None:
            self.stack1.append(x)
        else:
            while self.stack1:
                self.stack2.append(self.stack1.pop(-1))
            self.stack1.append(x)
            
            while self.stack2:
                self.stack1.append(self.stack2.pop(-1))
                
    def pop(self) -> int:
        """
        Removes the element from in front of queue and returns that element.
        """
        return self.stack1.pop()

    def peek(self) -> int:
        """
        Get the front element.
        """
        if self.stack1:
            return self.stack1[-1]

    def empty(self) -> bool:
        """
        Returns whether the queue is empty.
        """
        return len(self.stack1) == 0

 

例3:LeetCode155. 最小栈(easy)

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

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

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

分析：

思路：

代码：

class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.minstack  = []

    def push(self, x: int) -> None:
        self.stack.append(x)
        if not self.minstack or x < self.minstack[-1]:
            self.minstack.append(x)
        else:
            self.minstack.append(self.minstack[-1])
        

    def pop(self) -> None:
        if self.stack:
            self.minstack.pop()
            return self.stack.pop()  

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        if self.minstack:
            return self.minstack[-1]

 

例4:LeetCode215. 数组中的第K个最大元素(easy)

在未排序的数组中找到第 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

代码：

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

 

例5:LeetCode295. 数据流的中位数（hard)

中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。

例如，

[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 

分析：

思路：

具体情况：

代码：

import heapq
class MedianFinder:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.big_queue = []
        self.small_queue = []

    def addNum(self, num: int) -> None:
        if not self.big_queue:
            heapq.heappush(self.big_queue, (-num, num)) 
            #因为 Python 中的堆默认是小顶堆，所以要传入一个 tuple，用于比较的元素需是相反数，才能模拟出大顶堆的效果
            return
        
        if len(self.big_queue) == len(self.small_queue):
            if num < self.big_queue[0][1]:
                heapq.heappush(self.big_queue, (-num, num))
            else:
                heapq.heappush(self.small_queue, num)
                
        elif len(self.big_queue) > len(self.small_queue):
            if num < self.big_queue[0][1]:
                _, big_queue_top = heapq.heappop(self.big_queue)
                heapq.heappush(self.small_queue, big_queue_top)
                heapq.heappush(self.big_queue, (-num, num))
            else:
                heapq.heappush(self.small_queue, num)
                
        elif len(self.big_queue) < len(self.small_queue):
            if num < self.small_queue[0]:
                 heapq.heappush(self.big_queue, (-num, num))
            else:
                small_queue_top = heapq.heappop(self.small_queue)
                heapq.heappush(self.big_queue, (-small_queue_top, small_queue_top))
                heapq.heappush(self.small_queue, num)

    def findMedian(self) -> float:
        if len(self.big_queue) == len(self.small_queue):
            return (self.big_queue[0][1] + self.small_queue[0]) / 2
        elif len(self.big_queue) > len(self.small_queue):
            return self.big_queue[0][1]
        return self.small_queue[0]