栈【数据结构与算法笔记4】

注：2019-10-05充当笔记，暂时只用python，MOOC北大陈斌的课

关键词：

线性结构， 后进先出，次序反转， 单调栈

leetcode: 739每日温度

要点：1， 维护一个单调递减的栈。2，栈保存元素的位置而不是元素的值

def dailyTemp_init(T):  # 我刚开始的解法，这里很烂
    result = [0] * len(T)
    for i in range(len(T)-1):
        k = i+1
        while k < len(T):
            if T[k] < T[i]:
                result[i] += 1
            else:
                result[i] = k-i
                break
            k += 1
                
    for i in range(len(result)):
        if result[i] == len(result)- i-1:
            result[i] = 0
            
    return result
## -----------------------------------------------
def dailyTemp(T):    # 栈需要保存元素的位置而不是元素的值！！
    result = [0] * len(T)
    stack = []
    for i, k in enumerate(T):
        while stack and T[stack[-1]] < k:
            result[stack[-1]] = i-stack[-1]
            stack.pop()
            
        stack.append(i)
        
    return result

1，用python列表实现一个栈类：

一般写算法题时候直接list便好，不必单独构建stack
函数：is_empty，push， pop， peek， size【按字面意思理解作用】

class Stack():
    def __init__(self,):
        self.items = []
    def is_empty(self):
        return self.items == []
    def push(self, x):
        self.items.append(x)
    def pop(self):
        return self.items.pop()
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        return len(self.items)

2，通用括号匹配：

def parchecker_2(symbolString):
    checker = Stack()
    balanced = True
    index = 0
#     for char in symbolString:
    while index < len(symbolString) and balanced:
        char = symbolString[index]
        if char in '({[':
            checker.push(char)
        else:
            if checker.is_empty():
                balanced = False
            else:
                top = checker.pop()
                if not match(top, char):
                    balanced = False
        index += 1
        
    if balanced and checker.is_empty():
        return True
    else:
        return False
    
# 此函数用于判定不同括号是否匹配
def match(opens, closes):
    left = "({["
    right = ")}]"
    return left.index(opens) == right.index(closes)

3，中缀表达式转后缀：

priority：字典存储操作符优先级
要点：
1， 用栈保存所遇见的操作符.。2， 遇见第二个操作符的时候需要与栈顶比较优先级再做处理。

def mid2after(inputx):
    signstack = Stack()
    fixlist = []
    priority = {}
    priority['*'] = 3
    priority['/'] = 3
    priority['+'] = 2
    priority['-'] = 2
    priority['('] = 1
    
    tokenlist = inputx.split()
    print(tokenlist)
    for token in tokenlist:
        if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "1234567890": # token.isdigit()
            fixlist.append(token)
            print(fixlist)
        elif token == "(":
            signstack.push(token)
        elif token ==")":
            toptoken = signstack.pop()
            while toptoken != '(':
                fixlist.append(toptoken)
                toptoken = signstack.pop()
            
        else:
            while (not signstack.is_empty()) and (priority[signstack.peek()] >= priority[token]):
                fixlist.append(signstack.pop())
            signstack.push(token)
            
    while not signstack.is_empty():
        fixlist.append(signstack.pop())
        
    return " ".join(fixlist)