演算法就是設計，而設計無處不在，故演算法無處不在，但這是廢話，關鍵還是，要把握設計的套路，如果能發明套路就更不得了。設計套路中，有一個套路，是定製一個數據結構，就相當於定製出一個專用的厲害武器，然後用於解決特定的問題。

為了解決不同的問題，你可以定製出不同的資料結構。什麼是資料結構？就是資料的組織結構，有特點的結構。在諸多資料結構中，有一些是通用的，也就是可以用於很多問題場景，因此它也是常用的。

常用的資料結構中，有一個結構，叫作“棧”。棧，能獨立作為一個數據結構，在於它有自己的特點--由此可見，有特點才能自立門派。

棧的特點，是操作都在同一個地方進行，這個地方叫棧頂。入棧、出棧，都在棧頂進行，最先被處理的是最後進棧的元素，“來得早不如來得巧”，這可不是排隊。

注意，資料結構的棧，跟c語言記憶體管理中的“棧”不是一個概念。

棧的封裝實現，哪一門語言可以做到。

為了簡化語言的細節與難度，這裡選擇python，只因為它的易用性。而簡化語言的難度，是為了把精力放在演算法或資料結構的設計上，而不是糾結於“記憶體怎麼釋放”、“怎麼自動檢測型別”之類的節外生枝的問題上，專注很重要！

（一）棧的實現

python實現棧，很簡單，用list（列表）即可。

入棧：s.append('hello stack')
出棧：s.pop()
棧是否為空：not s
偷看一下棧頂：s[-1]
棧的長度：len(s)

比如：

s=[]
s.append(8)
len(s)      #1
s.pop()     #返回8
not s       #True，為空
s.append('hello')   
s.append(False) 
s.append(8.9)
len(s)      #3
s[-1]       #8.9
len(s)      #3
s.pop()     #8.9
len(s)      #2
not s       #False
 

pop或append後，棧頂的位置都在變化。

（二）棧的應用

任何一個數據結構，都是因為有應用的場景才存在，也就是時勢造英雄。但基於這個資料結構，是可以創造出新的演算法的，英雄也可造時勢。

棧也不例外。

下面舉例說說它的應用場景。

（1）判斷左右符號是否配對

左符號：([{，右符號：)]}，配對的情況如：'([]){()}'，不配對的情況如：'[{]}]'。

用棧來理解就是：

遍歷所有字元。
遇左符號則入棧；遇右符號則出棧（如果為空則直接返回False），出棧返回的字元如果與右符號不配對則返回False，如果配對則繼續下一個字元。
所有字元遍歷完後，棧非空則返回False，否則返回True。
 

def sybol_match(str):
    L=['(','{','['];
    R=[')','}',']'];
    s=[]
    for c in str:
        if c in L:
            s.append(c)
        else:
            if not s:
                return False
            a=s.pop()
            lp = L.index(a)
            rp = R.index(c)
            if lp!=rp:
                return False
    return not s

（2）計算字尾表示式

計算一個表示式時，表示式可以以中綴或字尾的方式錄入，而後綴表示式由於不使用括號而簡化處理，所以是一個普遍的選擇。

補充一下知識點，中綴表示式是我們常用的表達方式，也就是把符號放在數字中間，比如3+4，而字首或字尾是計算機喜歡的表達方式，因為它更易於解析。字首就是把符號放在數字前面，比如+ 3 4，而後綴就是符號在數字後面，比如3 4 +。

再比如：

中綴：12*(2/2)  字尾：12 2 2 / * 
中綴：10-(2*3) 字尾：10 2 3 * -
中綴：(3-2)*(9/3)+5     字尾：3 2 - 9 3 / * 5 + 

用棧來理解就是：

遍歷所有分割項（以空格切分）。
遇到數字則入棧；遇到操作符出棧兩次（這裡簡化為都是二元操作，第一次出棧的為引數2，第二次為引數1），並進行運算，再把結果入棧。
遍歷完所有分割項後，返回棧中內容（只有一個值）。

operators = {
        '+' : lambda p1, p2: p1+p2,
        '-' : lambda p1, p2: p1-p2,
        '*' : lambda p1, p2: p1*p2,
        '/' : lambda p1, p2: p1/p2,
        }
def calc_postfix(str):
    expr = str.split()
    s = []
    for e in expr:
        if e.isdigit():
            s.append(int(e))
        else:
            f = operators[e]
            p2 = s.pop()
            p1 = s.pop()
            s.append(f(p1, p2))

    return s.pop()

（3）揹包問題

有若干個物品，每一個物品都有重量。揹包有最大容量限制，求剛好裝滿揹包最大容量的所有解。

比如：

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

揹包最大可以裝10kg，那可能的解是：[0,2,3,5]、[1,5]等。

用棧來理解就是：

盡情地裝（按物品順序，只要能裝得下就裝），如果剩餘容量剛好為0或者之後的各個物品都裝不下了，則出棧，即拿掉最後的一個物品k，再繼續從k+1個物品開始裝。
棧為空而且填裝的物品的索引已經超出範圍，則結束迴圈。
由於，總會一直出棧到一個物品都沒有，再從下一個物品開始填裝，所以一定會出現棧為空且沒有物品可裝的情況。

def knapsack(w, ws):
    """
    w --揹包容量
    ws --物品重量列表 [1, 3, ..]
    """
    ret = []
    s = []
    i = 0
    cnt = len(ws)
    rest = w
    while s or i < cnt:  # 棧為空或者還有得裝
        while i < cnt and rest > 0:  # 還有得裝且還有容量
            if rest >= ws[i]:  # 裝得下就裝
                s.append(i)
                rest -= ws[i]
            i += 1   # 不管當前的是否裝得下，都要嘗試下一個
        if rest == 0:
            ret.append(s[:])  # one solution
        i = s.pop()
        rest += ws[i]
        i += 1
    return ret
        
if __name__ == '__main__':
    # print(sybol_match('[{()}]{}[()]()'))
    # print(sybol_match('[({}])'))
    # print(calc_postfix('12 2 2 / *'))
    # print(calc_postfix('3 2 - 9 3 / * 5 +'))
    ret = knapsack(10, [1, 8, 4, 3, 5, 2]) 
    print(ret)

（三）總結

工具的價值在於恰當的使用。棧，一個簡單的工具，可用於某類問題的解決。

但是，這裡的重點不是怎麼設計棧這個資料結構，而是，你要有一個意識，就是對於特定的問題，有可能要設計一個專用的資料結構並使用它，當然，通用的資料結構也是一個辦法。

---

相關推薦