蓝桥杯第2天基本数据结构栈&队列&链表

是小肖啊！

已于 2022-01-19 17:52:57 修改

阅读量759

点赞数 1

文章标签：蓝桥杯数据结构职场和发展

于 2022-01-19 17:43:19 首次发布

本文链接：https://blog.csdn.net/aixiaoxiao13/article/details/122580329

版权

1.栈

LIFO Last In First Out

用列表实现栈

class stack:
    def __init__(self):
        self.items=[]
    def isempty(self):
        return self.items==[]
    def push(self,item):
        self.items.append(item)
    def pop(self):
        self.items.pop()
    def peek(self):
        return self.items[len(self.items)-1]
    def size(self):
        return len(self.items)

2.使用栈来匹配括号

from pythonds.basic import Stack
def perchecker(symbolstring):
    s = Stack()
    balanced = True
    index = 0
    while(index<len(symbolstring) and balanced):
        symbol = symbolstring[index]
        if(symbol=='('):
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced=False
            else:
                s.pop()
        index+=1
    if balanced and s.isEmpty():
        return True
    else:
        return False

3.使用栈来匹配符号

主要是要多判断一下栈顶和当前拿来匹配的右符号是否相同

from pythonds.basic import Stack
def check(string):
    s=Stack()
    index=0
    balanced=True
    while index<len(string) and balanced:
        a = string[index]
        if(a in '([{'):
            s.push(a)
        else:
            if s.isEmpty():
                balanced=False
            elif matches(s.peek(),a):
                s.pop()
            else:
                balanced=False
        index += 1
    if balanced and s.isEmpty():
        return True
    else:
        return False
    
def matches(open,close):
    ins='([{'
    out=')]}'
    if(ins.index(open)==out.index(out)):
        return True
    else:
        return False

4.用栈将十进制转为二进制

一直重复以下两步，直到这个数为0

（1）对2取余，将余数压入栈中

（2）用2整除

最后完成时，栈顶的就是最高位，栈底的事最低位，用字符串把它们缝合起来就行

from pythonds.basic import Stack
def tentotwo(x):
    s = Stack()
    while x!=0:
        res = x%2
        s.push(res)
        x//=2
    ans=''
    while not s.isEmpty():
        ans+=str(s.pop())
    return ans

5.用栈将十进制转为任意进制

from pythonds.basic import Stack
def tentotwo(x,base):
    char='0123456789ABCDEF'
    s = Stack()
    while x!=0:
        res = x%2
        s.push(res)
        x//=2
    ans=''
    while not s.isEmpty():
        ans+=char[s.pop()]
    return ans

6.使用栈完成中序表达式往后序表达式转换

这种有悖于人脑逻辑的东西。。。

强记一下步骤：用一个列表来存储结果，一个栈来完成对符号的排列，从左到右扫描中序表达式

（1）如果是‘(’,压入栈

（2）如果是')',一直出栈，知道对应的(也出栈

（3）如果是操作数，直接加入列表

（4）如果是符号，加入栈中，但是在这之前得确保栈顶符号的优先级小于它，如果大于，就加入结果列表

from pythonds.basic import Stack
import string

def change(infix):
    prec={}
    prec["*"]=3
    prec["/"]=3
    prec["+"]=2
    prec["-"]=2
    prec["("]=1
    s=Stack()
    anslist=[]
    for i in infix:
        if i=='(':
            s.push(i)
        elif i in string.ascii_uppercase :
            anslist.append(i)
        elif i==')':
            while((not s.isEmpty()) and (s.peek()!=')')):
                anslist.append(s.pop())
        else:
            while(not s.isEmpty() and prec[s.peek()]>prec[i]):
                anslist.append(s.pop())
            s.push(i)
    while(not s.isEmpty()):
        anslist.append(s.pop())
    return " ".join(anslist)

print(change("A+B*C"))

7.使用栈计算后序表达式的值

使用一个栈即可

碰到操作数就压入栈，碰到操作符就从栈里弹出两个操作数

需要注意，第一个弹出的是右操作数，第二个弹出的是左操作数

根据操作符对这两个操作数进行运算，运算结果压入栈中

最后栈中就只剩下一个值，也就是答案

from pythonds.basic import Stack
def domath(a,b,c):
    if c=='+':
        return a+b
    elif c=='-':
        return a-b
    elif c=='*':
        return a*b
    else c=='/':
        return a/b
def caculate(postfix):
    s = Stack()
    for i in postfix:
        if i in "0123456789":
            s.push(int(i))
        else:
            y=s.pop()
            x=s.pop()
            ans=domath(x,y,i)
            s.push(ans)
    return s.pop()