「Python 算法實戰」：棧

棧(stack)又稱之爲堆棧是一個特殊的有序表，其插入和刪除操做都在棧頂進行操做，而且按照先進後出，後進先出的規則進行運做。

以下圖所示

例如槍的彈匣，第一顆放進彈匣的子彈反而在發射出去的時候是最後一個，而最後放入彈匣的一顆子彈在打出去的時候是第一顆發射出去的。

棧的接口

若是你建立了一個棧，那麼那麼應該具備如下接口來進行對棧的操做

接口	描述
push()	入棧
pop()	出棧
isEmpty()	判斷是否爲空棧
length()	獲取棧的長度
getTop()	取棧頂的元素，元素不出棧

知道棧須要上述的接口後，那麼在Python中，列表就相似是一個棧，提供接口以下：

操做	描述
s = []	建立一個棧
s.append(x)	往棧內添加一個元素
s.pop()	在棧內刪除一個元素
not s	判斷是否爲空棧
len(s)	獲取棧內元素的數量
s[-1]	獲取棧頂的元素

Python中的棧接口使用實例：

# 建立一個棧
In [1]: s = []
# 往棧內添加一個元素
In [2]: s.append(1)
In [3]: s
Out[3]: [1]
# 刪除棧內的一個元素
In [4]: s.pop()
Out[4]: 1
In [5]: s
Out[5]: []
# 判斷棧是否爲空
In [6]: not s
Out[6]: True
In [7]: s.append(1)
In [8]: not s
Out[8]: False
# 獲取棧內元素的數量
In [9]: len(s)
Out[9]: 1
In [10]: s.append(2)
In [11]: s.append(3)
# 取棧頂的元素
In [12]: s[-1]
Out[12]: 3

一大波實例

在瞭解棧的基本概念以後，讓咱們再來看幾個實例，以便於理解棧。

括號匹配

題目

假如表達式中容許包含三中括號()、[]、{}，其嵌套順序是任意的，例如：

正確的格式

{()[()]},[{({})}]

錯誤的格式

[(]),[()),(()}

編寫一個函數，判斷一個表達式字符串，括號匹配是否正確

思路

1. 建立一個空棧，用來存儲還沒有找到的左括號；
2. 便利字符串，遇到左括號則壓棧，遇到右括號則出棧一個左括號進行匹配；
3. 在第二步驟過程當中，若是空棧狀況下遇到右括號，說明缺乏左括號，不匹配；
4. 在第二步驟遍歷結束時，棧不爲空，說明缺乏右括號，不匹配；

解決代碼

建議在pycharm中打斷點，以便於更好的理解

#!/use/bin/env python
# _*_ coding:utf-8 _*_
LEFT = {'(', '[', '{'}  # 左括號
RIGHT = {')', ']', '}'}  # 右括號
def match(expr):
    """
    :param expr:  傳過來的字符串
    :return:  返回是不是正確的
    """
    stack = []  # 建立一個棧
    for brackets in expr:  # 迭代傳過來的全部字符串
        if brackets in LEFT:  # 若是當前字符在左括號內
            stack.append(brackets)  # 把當前左括號入棧
        elif brackets in RIGHT:  # 若是是右括號
            if not stack or not 1 <= ord(brackets) - ord(stack[-1]) <= 2:
                # 若是當前棧爲空，()]
                # 若是右括號減去左括號的值不是小於等於2大於等於1
                return False  # 返回False
            stack.pop()  # 刪除左括號
    return not stack  # 若是棧內沒有值則返回True，不然返回False
result = match('[(){()}]')
print(result)

迷宮問題

題目

用一個二維數組表示一個簡單的迷宮，用0表示通路，用1表示阻斷，老鼠在每一個點上能夠移動相鄰的東南西北四個點，設計一個算法，模擬老鼠走迷宮，找到從入口到出口的一條路徑。

如圖所示

出去的正確線路如圖中的紅線所示

思路

1. 用一個棧來記錄老鼠從入口到出口的路徑
2. 走到某點後，將該點左邊壓棧，並把該點值置爲1，表示走過了；
3. 從臨近的四個點中可到達的點中任意選取一個，走到該點；
4. 若是在到達某點後臨近的4個點都不走，說明已經走入死衚衕，此時退棧，退回一步嘗試其餘點；
5. 反覆執行第2、3、四步驟直到找到出口；

解決代碼

#!/use/bin/env python
# _*_ coding:utf-8 _*_
def initMaze():
    """
    :return: 初始化迷宮
    """
    maze = [[0] * 7 for _ in range(5 + 2)]  # 用列表解析建立一個7*7的二維數組，爲了確保迷宮四周都是牆
    walls = [  # 記錄了牆的位置
        (1, 3),
        (2, 1), (2, 5),
        (3, 3), (3, 4),
        (4, 2),  # (4, 3),  # 若是把(4, 3)點也設置爲牆，那麼整個迷宮是走不出去的，因此會返回一個空列表
        (5, 4)
    ]
    for i in range(7):  # 把迷宮的四周設置成牆
        maze[i][0] = maze[i][-1] = 1
        maze[0][i] = maze[-1][i] = 1
    for i, j in walls:  # 把全部牆的點設置爲1
        maze[i][j] = 1
    return maze
"""
[1, 1, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 1]
[1, 0, 0, 1, 1, 0, 1]
[1, 0, 1, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 1]
[1, 1, 1, 1, 1, 1, 1]
"""
def path(maze, start, end):
    """
    :param maze: 迷宮
    :param start: 起始點
    :param end: 結束點
    :return: 行走的每一個點
    """
    i, j = start  # 分解起始點的座標
    ei, ej = end  # 分解結束點的左邊
    stack = [(i, j)]  # 建立一個棧，並讓老鼠站到起始點的位置
    maze[i][j] = 1  # 走過的路置爲1
    while stack:  # 棧不爲空的時候繼續走，不然退出
        i, j = stack[-1]  # 獲取當前老鼠所站的位置點
        if (i, j) == (ei, ej): break  # 若是老鼠找到了出口
        for di, dj in [(0, -1), (0, 1), (-1, 0), (1, 0)]:  # 左右上下
            if maze[i + di][j + dj] == 0:  # 若是當前點可走
                maze[i + di][j + dj] = 1  # 把當前點置爲1
                stack.append((i + di, j + dj))  # 把當前的位置添加到棧裏面
                break
        else:  # 若是全部的點都不可走
            stack.pop()  # 退回上一步
    return stack  # 若是迷宮不能走則返回空棧
Maze = initMaze()  # 初始化迷宮
result = path(maze=Maze, start=(1, 1), end=(5, 5))  # 老鼠開始走迷宮
print(result)
# [(1, 1), (1, 2), (2, 2), (3, 2), (3, 1), (4, 1), (5, 1), (5, 2), (5, 3), (4, 3), (4, 4), (4, 5), (5, 5)]

後綴表達式求值

題目

計算一個表達式時，編譯器一般使用後綴表達式，這種表達式不須要括號：

中綴表達式	後綴表達式
2 + 3 * 4	2 3 4 * +
( 1 + 2 ) * ( 6 / 3 ) + 2	1 2 + 6 3 / * 2 +
18 / ( 3 * ( 1 + 2 ) )	18 3 1 2 + * /

編寫程序實現後綴表達式求值函數。

思路

1. 創建一個棧來存儲待計算的操做數；
2. 遍歷字符串，遇到操做數則壓入棧中，遇到操做符號則出棧操做數(n次)，進行相應的計算，計算結果是新的操做數壓回棧中，等待計算
3. 按上述過程，遍歷完整個表達式，棧中只剩下最終結果；

解決代碼

#!/use/bin/env python
# _*_ coding:utf-8 _*_
operators = {  # 運算符操做表
    '+': lambda op1, op2: op1 + op2,
    '-': lambda op1, op2: op1 - op2,
    '*': lambda op1, op2: op1 * op2,
    '/': lambda op1, op2: op1 / op2,
}
def evalPostfix(e):
    """
    :param e: 後綴表達式
    :return: 正常狀況下棧內的第一個元素就是計算好以後的值
    """
    tokens = e.split()  # 把傳過來的後綴表達式切分紅列表
    stack = []
    for token in tokens:  # 迭代列表中的元素
        if token.isdigit():  # 若是當前元素是數字
            stack.append(int(token))  # 就追加到棧裏邊
        elif token in operators.keys():  # 若是當前元素是操做符
            f = operators[token]  # 獲取運算符操做表中對應的lambda表達式
            op2 = stack.pop()  # 根據先進後出的原則，先讓第二個元素出棧
            op1 = stack.pop()  # 在讓第一個元素出棧
            stack.append(f(op1, op2))  # 把計算的結果在放入到棧內
    return stack.pop()  # 返回棧內的第一個元素
result = evalPostfix('2 3 4 * +')
print(result)
# 14

揹包問題

題目

有一個揹包能裝10kg的物品，如今有6件物品分別爲：

物品名稱	重量
物品0	1kg
物品1	8kg
物品2	4kg
物品3	3kg
物品4	5kg
物品5	2kg

編寫找出全部能將揹包裝滿的解，如物品1+物品5。

解決代碼

#!/use/bin/env python
# _*_ coding:utf-8 _*_
def knapsack(t, w):
    """
    :param t: 揹包總容量
    :param w: 物品重量列表
    :return:
    """
    n = len(w)  # 可選的物品數量
    stack = []  # 建立一個棧
    k = 0  # 當前所選擇的物品遊標
    while stack or k < n:  # 棧不爲空或者k<n
        while t > 0 and k < n:  # 還有剩餘空間而且有物品可裝
            if t >= w[k]:  # 剩餘空間大於等於當前物品重量
                stack.append(k)  # 把物品裝備揹包
                t -= w[k]  # 揹包空間減小
            k += 1  # 繼續向後找
        if t == 0:  # 找到了解
            print(stack)
        # 回退過程
        k = stack.pop()  # 把最後一個物品拿出來
        t += w[k]  # 揹包總容量加上w[k]
        k += 1  # 裝入下一個物品
knapsack(10, [1, 8, 4, 3, 5, 2])
"""
[0, 2, 3, 5]
[0, 2, 4]
[1, 5]
[3, 4, 5]
"""