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]