2. 程式人生 > >python資料結構之棧、佇列與堆

python資料結構之棧、佇列與堆

阿新 • • 發佈：2019-02-01

目錄

  1. 棧與佇列的基礎知識
  2. 使用佇列實現棧 (LeetCode 225)
  3. 使用棧實現佇列 (LeetCode 232)
  4. 包含min函式的棧(LeetCode 155)
  5. 合法的出棧序列
  6. 堆的必備基礎知識
  7. 陣列中的第K大的數 (LeetCode 215)
  8. 尋找中位數(LeetCode 295)

1. 棧與佇列的基礎知識

  • 棧(stacks)是一種只能通過訪問其一端來實現資料儲存與檢索的線性資料結構，具有後進先出(last in first out，LIFO)的特徵

  • 佇列(queue)是一種具有先進先出特徵的線性資料結構，元素的增加只能在一端進行，元素的刪除只能在另一端進行。能夠增加元素的佇列一端稱為隊尾，可以刪除元素的佇列一端則稱為隊首。python庫from collections import deque

    可以實現，popleft()。

2. 使用佇列實現棧 (LeetCode 225 Implement Stack using Queues)

2.1題目

Implement the following operations of a stack using queues.

push(x) – Push element x onto stack.
pop() – Removes the element on top of the stack.
top() – Get the top element.
empty() – Return whether the stack is empty.
Notes:
You must use only standard operations of a queue – which means only push to back, peek/pop from front, size, and is empty operations are valid.
Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

2.2思路

棧是後進先出，佇列是先進先出，佇列在python中要使用collections.dequeue()
要用隊列表示棧，則在元素入棧時對棧元素的順序進行調整，將最後元素之前的元素按順序移動到最後一個元素的後面，使最後一個進入的元素位於佇列的前面。

2.3程式碼

class MyStack(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.stack = collections.deque([])


    def
 
 push(self, x):
        """
        self.stack = []
        Push element x onto stack.
        :type x: int
        :rtype: void
        """
        self.stack.append(x)
        q = self.stack
        for i in range(len(q) - 1):
            q.append(q.popleft())


    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        return self.stack.popleft()


    def top(self):
        """
        Get the top element.
        :rtype: int
        """
        return self.stack[0]

    def empty(self):
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        if len(self.stack) == 0:
            return True
        else:
            return False

3. 使用棧實現佇列 (LeetCode 232)

3.1題目

Implement the following operations of a queue using stacks.

push(x) – Push element x to the back of queue.
pop() – Removes the element from in front of queue.
peek() – Get the front element.
empty() – Return whether the queue is empty.
Notes:
You must use only standard operations of a stack – which means only push to top, peek/pop from top, size, and is empty operations are valid.
Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).

3.2思路

棧是後進先出，佇列是先進先出
可以使用2個棧來表示，一個表示入棧，還有一個表示出棧，出棧的順序與入棧的順序相反

3.3程式碼

class MyQueue(object):

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

    def push(self, x):
        """
        Push element x to the back of queue.
        :type x: int
        :rtype: void
        """
        self.input.append(x)

    def pop(self):
        """
        Removes the element from in front of queue and returns that element.
        :rtype: int
        """
        self.peek()
        return self.output.pop()


    def peek(self):
        """
        Get the front element.
        :rtype: int
        """
        if self.output == []:
            while self.input:
                self.output.append(self.input.pop())
        return self.output[-1]

    def empty(self):
        """
        Returns whether the queue is empty.
        :rtype: bool
        """
        return self.input == [] and self.output == []

4. 包含min函式的棧(LeetCode 155 Min Stack)

4.1題目

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

push(x) – Push element x onto stack.
pop() – Removes the element on top of the stack.
top() – Get the top element.
getMin() – Retrieve the minimum element in the stack.
Example:

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

4.2思路

使用2個列表，一個用於表示棧，用來壓入資料和彈出資料，還有一個表示最小數的列表minstack，當minstack==[]或者當前元素小於minstack的棧頂元素時，則將該元素壓入minstack，從而保證minstack的最後一個元素是當前所有元素中最小的。彈棧時注意棧頂元素與minstack的棧頂元素是否相等，若相等，則將兩個列表的棧頂元素都彈出，否則只彈出資料棧的棧頂元素

4.3程式碼

class MinStack(object):

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


    def push(self, x):
        """
        :type x: int
        :rtype: void
        """
        self.stack.append(x)
        if self.minstack == [] or x <= self.minstack[-1]:
            self.minstack.append(x)



    def pop(self):
        """
        :rtype: void
        """
        if self.stack != []:
            if self.stack[-1] == self.minstack[-1]:
                self.minstack.pop()
            self.stack.pop()


    def top(self):
        """
        :rtype: int
        """
        if self.stack != []:
            return self.stack[-1]
        else:
            return None


    def getMin(self):
        """
        :rtype: int
        """
        if self.minstack != []:            
            return self.minstack[-1]
        else:
            return None

5. 合法的出棧序列

5.1題目

輸入兩個整數序列，第一個序列表示棧的壓入順序，請判斷第二個序列是否為該棧的彈出順序。假設壓入棧的所有數字均不相等。例如序列1,2,3,4,5是某棧的壓入順序，序列4，5,3,2,1是該壓棧序列對應的一個彈出序列，但4,3,5,1,2就不可能是該壓棧序列的彈出序列。（注意：這兩個序列的長度是相等的）

5.2思路

新建立一個棧用於模仿棧的壓入和彈出，若彈出序列正確，則這個新建立的棧應該為空

5.3程式碼

Class Solution:
    def IsPopOrder(self, pushV, popV):
        if pushV == [] or popV == []:
            return False
        stack = []
        for i in pushV:
            stack.append(i)
            while len(stack) and stack[-1] == popV[0]:
                stack.pop()
                popV.pop(0)
        if stack != []:
            return False
        else:
            return True

6. 堆的必備基礎知識

二叉堆：是一棵特殊的完全二叉樹，其特點：

  • 二叉樹中的所有的父節點的值都不大於/不小於其子節點；
  • 根節點的值必定是所有節點中最小/最大的

將父節點的值不大於子節點且根節點值最小的稱為最小堆，反之稱為最大堆。堆是一種高階的資料結構，在python中有相應的模組deapq

7. 陣列中的第K大的數 (LeetCode 215 Kth Largest Element in an Array)

7.1題目

Find the kth largest element in an unsorted array. Note that it is the kth largest element in the sorted order, not the kth distinct element.
For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

Note:
You may assume k is always valid, 1 ≤ k ≤ array’s length.**

7.2思路

思路1：先對陣列排序，再求解第k個元素
思路2：使用最小堆做，第k大的數即len(q)-k小的元素

7.3程式碼

#排序法
class Solution(object):
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        nums.sort()
        return nums[-k]
#最小堆法
class Solution(object):
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        heap = []
        for num in nums:
            heapq.heappush(heap, num)
        for i in range(len(nums) - k):
            heapq.heappop(heap)
        return heapq.heappop(heap)

8. 尋找中位數(LeetCode 295 Find Median from Data Stream)

8.1題目

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:
[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Design a data structure that supports the following two operations:

void addNum(int num) - Add a integer number from the data stream to the data structure.
double findMedian() - Return the median of all elements so far.

8.2思路

維護兩個堆，一個是大頂堆，一個是小頂堆,使用python內建庫heapq。
這裡寫圖片描述
如上圖所示，每次新增元素時保證0<=len(maxheap)−len(minheap)<=1，且max<=min
因為heap[0]表示的是堆中最小的元素，所以要使heap[0]表示的是堆中最大的元素，則將加入該堆的所有元素取負。新增元素時，首先將該元素取負加入maxheap中，然後對maxheap和minheap進行調整：如果maxheap中的最大元素比minheap中的最小元素要大或者len(maxheap)>len(minheap)+1，彈出maxheap中的最大元素加入minheap中；如果len(maxheap)<len(minheap)，則將minheap中的最小元素加入maxheap中。
求中位數時，如果陣列長度為奇數，則返回max，是偶數，則返回(max+min)/2

8.3程式碼

from heapq import *
class MedianFinder(object):
    def __init__(self):
        """
        initialize your data structure here.
        """
        self.minHeap = []
        self.maxHeap = []

    def addNum(self, num):
        """
        :type num: int
        :rtype: void
        """
        heappush(self.maxHeap, -num)
        minTop = self.minHeap[0] if len(self.minHeap) else None
        maxTop = self.maxHeap[0] if len(self.maxHeap) else None
        if minTop < -maxTop or len(self.minHeap) + 1 < len(self.maxHeap):
            heappush(self.minHeap, -heappop(self.maxHeap))
        if len(self.maxHeap) < len(self.minHeap):
            heappush(self.maxHeap, -heappop(self.minHeap))
    def findMedian(self):
        """
        :rtype: float
        """
        if len(self.minHeap) < len(self.maxHeap):
            return -1.0 * self.maxHeap[0]
        else:
            return (self.minHeap[0] - self.maxHeap[0]) / 2.0

相關推薦

python資料結構之棧、佇列與堆

目錄 棧與佇列的基礎知識 使用佇列實現棧 (LeetCode 225) 使用棧實現佇列 (LeetCode 232) 包含min函式的棧(LeetCode 155) 合法的出棧序列 堆的必備基礎知識 陣列中的第K大的數 (LeetCode 215) 尋找中位

python資料結構之棧和佇列

1.功能實現 之前文章有，可以點開看看 棧 佇列 2.應用(1)括號匹配及字尾表示式 class Solution(object): def isValid(self, s): """ :type s: str :rtype

Python資料結構之: 棧與佇列

棧(stacks) 是一種只能通過訪問其一端來實現資料儲存與檢索的線性資料結構，具有後進先出(last in first out，LIFO)的特徵 stack = [] stack.append("A") #A入棧 stack.append("B") #B入棧 st

python資料結構之列表、元組及元組與列表之間的相互轉換

一、列表（list） # names="chenyanhui wujiawei heweimin zhouqingxiang" # print(names) names=["chenyanhui","wujiawei","heweimin","tu

資料結構之棧和佇列

棧和佇列是兩種重要的線性結構。從資料結構角度來看，棧和佇列也是線性表，它們是操作受限的線性表，被稱為限定性的資料結構。 棧（Stack） 棧是限定僅在表尾進行插入或刪除操作的線性表。 表尾端被稱為棧頂（top），表頭端稱為棧底（bottom），不含元素的空表稱為空棧。

常見的資料結構（棧、佇列、陣列、連結串列和紅黑樹）

（一）棧 棧：stack,又稱堆疊，它是運算受限的線性表，其限制是僅允許在標的一端進行插入和刪除操作，不允許在其 他任何位置進行新增、查詢、刪除等操作。 簡單的說：採用該結構的集合，對元素的存取有如下的特點先進後出（即，存進去的元素，要在後它後面的元素依次取出後，才能取出該元素）。例如，子彈

python資料結構之列表、元組

（與字串和元組的區別）列表是可變的----------可以改變列表的內容，並且列表中含有很多有用的專門的方法。 list函式： 可以將字串建立成列表 程式碼： a=list('Hello') print(a) 輸出： ['H', 'e', 'l', 'l', 'o'] 基本的

python資料結構之列表、字典、元組、集合

列表 列表在python裡是有序集合物件型別。列表裡的物件可以是任何物件：數字，字串，列表或者字典，元組。與字串不同，列表是可變物件，支援原處修改的操作python的列表是： 任意物件的有序集合 通過偏移讀取 可變長度、異構以及任意巢狀 屬於可變序列的分組 物件引用陣列 列表的

js資料結構之棧和佇列

棧是一種遵從後進先出（LIFO）原則的有序集合。新新增的或待刪除的元素都儲存在棧末尾，稱作棧頂，另一端稱作棧底。在棧裡，新元素都靠近棧頂，舊元素就接近棧底。 佇列是遵循先進先出（FIFO）原則的一組有序的項。佇列在尾部新增新元素，並從頂部移除元素。最新新增的元

C++資料結構之棧和佇列

棧和佇列也是常用的資料結構。棧“先進後出”的性質使得它有很多的應用，如果你學過組合語言，在設計程式時，中斷出現，要響應中斷，那麼程式中的重要暫存器資訊就要壓入棧中，等中斷程式執行完把斷點處的資訊出棧；

Python 資料結構之列表、元組

資料型別之列表、元組        今天來分享一下關於列表和元組的學習心得。本篇是資料型別系列的倒數第二篇，最後一篇我們單獨留給元組，同時會在該篇中解釋原因，敬請期待。        關於列表，這一型別可以說是與之前所分享的 集合 型別相似。但是，僅僅是相似而已，還是存在

三、資料結構演算法-棧、佇列、優先佇列、雙端佇列

## 一、Stack （棧） ### 1、資料結構 　　Stack是棧。它的特性是：**先進後出(FILO, First In Last Out) 後進先出（Last in - First out）**。java工具包中的Stack是繼承於Vector(向量佇列)的，由於Vector是通過陣列實現的，這就意味

python 資料結構之佇列和棧

# 棧是一種特殊的線性表，僅能線上性表的一端操作，棧頂允許操作，棧底不允許操作。 # 棧的特性：後進先出 class Stack(object): """棧""" def __init__(self): self.items=[] def is_empty(s

資料結構之棧與佇列數學表示式的求值

數學表示式的計算 #pragma once #include <stack> #include <deque> using namespace std; typedef struct { double opnd; //運算元 char o

Python資料結構之二叉樹（涵蓋了構建、刪除、查詢、字典轉換、非遞迴與遞迴遍歷等）

MyTree.py #coding=utf-8 import math class BinTree: def __init__(self): self.root=None def is_empty(self):

C語言資料結構之棧與佇列的應用（2）

輸入一個表示式，表示式中包括三種括號“（）”、“[]”和“{}”，判斷該表示式的括號是否匹配。 #include<stdio.h> #include<stdlib.h> #de

資料結構之棧與佇列的面試題：判斷字串是否按照出棧順序

可能這個題目猛一看，並不知道題目要求是什麼，讓我們做什麼。首先我們來說說這個題目大意。 給定一個字串，如：a b d e c 一個棧的入棧順序為：a b c d e 那麼出棧順序顯而易見：e d c b a 題目意思為：字串 a b d e c 是否能按

資料結構之雜湊表與連結串列、陣列

雜湊表 主要描述雜湊表的定義：通過關鍵碼尋找值的資料對映結構，類似於查字典 當存在雜湊衝突時，有兩種常用的方式：開發定址法和鏈地址法 開發定址法通俗的來說就是判斷該地址是否存資料，沒存就放進去，存了就找下一個地址，依次類推，問題是如果空間不足，無法處理衝突。 鏈地

資料結構（揹包、佇列和棧）

一.揹包 　　揹包是一種不支援從中刪除元素的集合資料型別，目的是幫助用例收集元素並迭代所有收集到的元素，也可以檢查揹包是否為空，或者獲取揹包中元素的數量。揹包裡面的元素的順序不確定。 　　要理解揹包的概念，可以想象一個喜歡收集彈珠球的人。他將所有的彈珠球都放在一個揹包裡，一次一個，並且會不時在所有的彈珠球中尋

資料結構之棧實現檢查左右括號是否匹配

def isValid(self,s): stack = [] paren_map = {')': '(', ']': '[', '}': '{'} for c in s: if c not in paren_map: stack.appe