栈Stack在python里的实现 数据结构与算法第三讲_基本结构上_

0、线性结构

线性结构是一种有序数据项的集合，其中每个数据项都有唯一的前驱和后继。除了第一个和最后一个。

常见的数据结构类型：栈Stack、队列Queue、双端队列Deque和列表List。

1、栈Stack

栈是一种后进先出的数据结构（LIFO)。

栈在Python里的实现：

我们借助list的一些基本功能来实现栈。

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

下面是一些栈的应用例子。
例1：括号匹配

def checkpar(string):
    s = Stack()
    balanced = True
    index = 0
    for i in string:
        if i in '(<{[':
            s.push(i)
        else:
            if i in ')>}]':
                if s.isEmpty():
                    balanced = False
                    break
                else:
                    top = s.pop()
                    if not matches(top,i):
                        balanced = False
                        break
    if balanced and s.isEmpty():
        return True
    else:
        return False
    
def matches(first,second):
    left='(<{['
    right=')>}]'
    return (left.index(first) == right.index(second))
#检验
print(checkpar('({[<>]()}[])'))

返回结果：True

例二：十进制转其他进制（十六进制以下）：

def ten2other(num,base):
    s = Stock()
    digits = '0123456789ABCDEF'
    while num>0:
        rem = num % base
        s.push(rem)
        num = num//base
        
    new = ''
    while not s.isEmpty():
        new += digits[s.pop()]
    return new

例3：中缀表达式（一般表达式）转后缀表达式。

def infix2postfix(expr):
    pre = {'(':1,'+':2,'-':2,'*':3,'/':3}
    s = Stack()
    postfix = []
    expr = expr.split()
    
    for i in expr:
        if i.isalnum():
            postfix.append(i)
        elif i =='(':
            s.push(i)
        elif i==')':
            top = s.pop()
            while top != '(':
                postfix.append(top)
                top = s.pop()
        else:
            while (not s.isEmpty())and(pre[i]<=pre[s.peek()]):
                postfix.append(s.pop())
            s.push(i)    
            
    while not s.isEmpty():
        postfix.append(s.pop())
    return ' '.join(postfix)
#检验
print(infix2postfix('13 + 2 * A - B'))

得到：13 2 A * + B -

例4：后缀表达式求值

def calpostfix(expr):
    s = Stack()
    expr = expr.split()
    
    for i in expr:
        if i.isalnum():
            s.push(i)
        else:
            first = s.pop()
            second = s.pop()
            result = eval(second+i+first)
            s.push(str(result))
    return s.pop()
#验证
A=3
B=2
print(calpostfix('13 2 A * + B -'))

得到：17