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]