数据结构-邓俊辉视频（Python代码-栈与队列Chap4）

这里使用Chap3定义好的链表类作为父类继承，邓俊辉使用的Vector类作为父类继承。栈顶有所区别

#stack.py 栈的接口与实现
import DisorderDoublelinkedlist as ll #第三章代码DisorderDoublelinkedlist.py
class stack(ll.Doublelinkedlist):
    #像弹夹一样的栈
    #先进后出，后进先出
    #当用向量派生的时候，是尾端push，尾端remove，尾端top，操作都是O(1)。栈顶是尾端
    #这里是用链表派生的，故是首端push，首端remove，首端top，操作都是O(1)。若链表派生与向量派生一样操作，那么操作都是O(n)。栈顶是首段
    def push(self,e):
        '''入栈'''
        self.insertBefore(0,e)

    def pop(self):
        '''出栈'''
        return self.remove(0)

    def top(self):
        '''取顶'''
        return (self)[0]

if __name__ == '__main__':
    Dll = stack()
    for i in [1, 1, 2, 4, 7, 8, 7]:
        Dll.push(i)
    print(Dll)
    print("top:",Dll.top())
    print("pop:",Dll.pop())
    print("删除后：",Dll)

栈的应用

import stack
#栈的应用
#1.进制转换
def convert(num,base):
    '''将10进制数num转化为base进制数'''
    digit = ['0',"1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]
    S = stack.Stack()
    while(num > 0):
        value = num % base
        num //= base
        S.push(digit[value])

    while S.size > 0:
        print(S.pop())

#convert(89,2)
print("第一题：")
convert(2013,5)
print("……………………………………")

#2.多括号匹配
def paren(exp):
    dic = {")":"(","}":"{","]":"["}
    S = stack.Stack()
    for value in exp:
        if value in dic.values():
            S.push(value)
        elif S.size == 0:
            return False
        else:
            if dic[value] != S.pop():
                return False
    return S.size == 0
print("第二题：")
#exp = ["(",")","(","(",")",")"]
exp = ["(",")","{","{","[","]"]
print(paren(exp))
print("……………………………………")

#3.栈混洗
#A top:1->2->3:tail
#S push 1,push 2,pop 2,pop 1,push 3
#B top:2->1->3
def shufflestack(innum,outnum):
    '''innum与outnum是list，他们的首元素代表栈顶'''
    S = stack.Stack()
    n = len(innum)
    i = 0
    for j in outnum:
        while j!=S.top():
            S.push(innum[i])
            i+=1
            if i > n-1:
                return False

        if S.size != 0:
            S.pop()
        else:
            return False
    return True
print("第三题：")
#innum = [1,2,3]
#outnum = [2,1,3]
innum = [1,2,3]
outnum = [3,1,2]
print("是否栈混洗：",shufflestack(innum,outnum))
print("……………………………………")

栈的应用-实现复杂计算器（中缀表达式求值与逆波兰表达式）
这道题真的厉害了，向邓老师鞠躬🙇‍♀️

import stack
import re

class Caculator:
    def __init__(self):
        self.__input = re.findall(".",input("请输入表达式："))
        #[栈顶][当前]
        self.pri = {
            "+": {"+": ">", "-": ">", "*": "<", "/": "<", "^": "<", "!": "<", "(": "<", ")": ">", "$": ">"},
            "-": {"+": ">", "-": ">", "*": "<", "/": "<", "^": "<", "!": "<", "(": "<", ")": ">", "$": ">"},
            "*": {"+": ">", "-": ">", "*": ">", "/": ">", "^": "<", "!": "<", "(": "<", ")": ">", "$": ">"},
            "/": {"+": ">", "-": ">", "*": ">", "/": ">", "^": "<", "!": "<", "(": "<", ")": ">", "$": ">"},
            "^": {"+": ">", "-": ">", "*": ">", "/": ">", "^": ">", "!": "<", "(": "<", ")": ">", "$": ">"},
            "!": {"+": ">", "-": ">", "*": ">", "/": ">", "^": ">", "!": ">", "(": " ", ")": ">", "$": ">"},
            "(": {"+": "<", "-": "<", "*": "<", "/": "<", "^": "<", "!": "<", "(": "<", ")": "=", "$": " "},
            ")": {"+": " ", "-": " ", "*": " ", "/": " ", "^": " ", "!": " ", "(": " ", ")": " ", "$": " "},
            "$": {"+": "<", "-": "<", "*": "<", "/": "<", "^": "<", "!": "<", "(": "<", ")": " ", "$": "="}
        }
        self.__input += "$"
        self.num = stack.Stack()#运算数栈
        self.st = stack.Stack()#运算符栈
        self.RPN = []

        self.st.push("$")
        self.i = 0

        number = ''
        while self.st.size != 0:
            if self.__input[self.i] in self.pri:
                self.switch()
                number = ''
            else:
                number = number + self.__input[self.i]
                if self.__input[self.i+1] in self.pri:
                    self.num.push(eval(number))
                    self.RPN.append(eval(number))
                self.i += 1

    def switch(self):
        st = self.pri[self.st.top()][self.__input[self.i]]
        if st == "<":
            self.st.push(self.__input[self.i])
            self.i += 1
        elif st == "=":
            self.st.pop()
            self.i += 1
        elif st == ">":
            op = self.st.pop()
            self.RPN.append(op)
            if op == "!":
                value = self.fac(self.num.pop())
                self.num.push(value)
            elif op != "^":
                num2 = self.num.pop()
                num1 = self.num.pop()
                value = eval("%d%s%d"%(num1,op,num2))
                self.num.push(value)
            else:
                num2 = self.num.pop()
                num1 = self.num.pop()
                value = self.power(num1,num2)
                self.num.push(value)

    def fac(self,n):
        an = 1
        for i in range(n):
            an *= (i+1)
        return an

    def power(self,a,b):
        return a**b

    def run(self):
        print("RPN:",self.RPN)
        return self.num.pop()

a = Caculator().run()
print(a)
#(1+2^3!-4)*(5!-(6-(7-(89-0!)))) = 2013
#0!+123+4*(5*6!+7!/8)/9

队列

#队列,像羽毛球桶一样的，先进先出，在队列尾部插入，顶部删除或查询
import DisorderDoublelinkedlist as ll
class Queque(ll.Doublelinkedlist):
    def enqueue(self,e): #O(n)
        self.insertBefore(self.size,e)

    def dequeue(self): #O(1)
        return self.remove(0)

    def front(self):
        return (self)[0]

if __name__ == '__main__':
    Dll = Queque()
    for i in [1, 1, 2, 4, 7, 8, 7]:
        Dll.enqueue(i)

    print("Dll：",Dll)
    print("删除：",Dll.dequeue())
    print("删除后：",Dll)
    print("首元素：",Dll.front())