python數據結構與算法——棧

1：逆波蘭表達式：

逆波蘭表達式(Reverse Polish Notation)：有效的運算符包括 +, -, *, / 。
每個運算對象可以是整數，也可以是另一個逆波蘭表達式。
輸入: ["2", "1", "+", "3", "*"]
輸出: 9
解釋: ((2 + 1) * 3) = 9

分析：棧
遍歷數組，逐漸壓入棧中，如果遇到運算字符，則彈出棧頂兩個元素，之後將計算結果再壓入棧中

class Solution:
    def rpn(self,s):
        
        stack=[]
        operation=['+','-','*','/']
        
        for i in range(len(s)):
            if s[i] not in operation:
                stack.append(int(s[i]))
            else:
                if stack and i>=2:
                    a=stack.pop()
                    b=stack.pop()
                    if s[i]=='+':
                        res=b+a
                        stack.append(res)
                    if s[i]=='-':
                        res=b-a
                        stack.append(res)
                    if s[i]=='*':
                        res=b*a
                        stack.append(res)
                    if s[i]=='/':
                        res=int(b/a) #除法只保留整數部分
                        stack.append(res)
                else:
                    return 0
        return stack[-1]
            
if __name__=='__main__':
    s=["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
    solution=Solution()
    print(solution.rpn(s))   

2：有效括號

分析：當遇到左邊括號，依次壓入棧中；
當遇到右邊的括號，檢查棧頂的元素
如果是相同的元素，彈出棧頂元素，不相同意味着表達式無效。
如果到最後棧中仍有元素存在，這表達式無效

eg：輸入: "()[]{}"   輸出: true

class Solution:
    def isValid(self,s):
        
        stack=[]
               
        left_bracket=['(','[','{']
        right_bracket=[')',']','}']

        for i in s:
            if i in left_bracket:
                stack.append(i) #壓棧
            else:
                if stack[-1]==left_bracket[right_bracket.index(i)]:
                    stack.pop()#彈棧
                else:
                    return False 
        if not stack:
            return True
        else:
            return False
        
if __name__=='__main__':
    s='()[]{}'
    solution=Solution()
    print(solution.isValid(s))

3：刪除字符串中所有的相鄰重複相

輸入："abbaca"
輸出："ca"

分析：棧的思路
遍歷數組，若與棧頂元素相同，彈出棧頂元素；
若不相同，壓入棧

class Solution:
    def removeDuplicates(self,S):
        
        stack=[]
       
        for i in S:
            if not stack or i!=stack[-1]:
                stack.append(i)
            else:
                stack.pop()
                
        return ''.join(stack)
    
if __name__=='__main__':
    S="abbccad"
    solution=Solution()
    print(solution.removeDuplicates(S)) 

4:最小棧：

典型的以空間換時間：創建一個輔助棧min_stack
壓棧：如果當前壓入棧的x小等於min_stack棧頂的值，則將x壓入min_stack
彈出：如果當前彈出的元素等於min_stack棧頂的值，則將min_stack棧頂元素隨之一起彈出
最後：返回min_stack棧頂元素

class MinStack:
    
    def __init__(self):
        #初始化兩個空棧   
        self.stack=[]
        self.min_stack=[]
        
    def push(self,x):#壓棧
        self.stack.append(x)
        if not self.min_stack or x<=self.min_stack[-1]:
            self.min_stack.append(x)
        
    def pop(self):#彈棧
        if self.stack.pop()==self.min_stack[-1]:
            self.min_stack.pop()
     
    def top(self):#獲取棧頂元素
        return self.stack[-1]
            
    def getMin(self):#獲取棧的最小值
        return self.min_stack[-1]