数据结构与算法（6）——栈Stack

• 基础定义

什么是栈：栈是一种有次序的数据项集合。在栈中，数据项的加入和移除都仅仅发生在同一端，这一端叫栈顶（top），没有操作的另一端叫栈底（base）。

特性：后进先出，先进后出

• 栈的基本操作

这里需要知道在python里面是没有栈的，但是我们可以模拟一个栈。

首先我们需要定义的一些栈的基本操作：

Stack()	创建一个空栈，不包含任何数据项
push(item)	将item加入栈顶，无返回值
pop()	将栈顶数据项移除，并返回，栈被修改
peek()	查看栈顶数据项，返回栈顶数据项但不移除，且不修改栈
isEmpty()	返回栈是否为空
size()	返回栈中有多少个数据项

 

这里，我们可以用list类型实现一个栈的操作：

class Stack:
    '''
    自己定义的一个栈
    '''
    def __init__(self):
        self.items =[]
    def isEmpty(self):
        return self.items==[]
    def push(self,item):
        return 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)
if __name__ == '__main__':
    s = Stack()
    s.push('1')
    s.push('a')
    print(s.isEmpty())
    print(s.peek())
    print(s.size())

[out]:
False
a
2

Process finished with exit code 0

• 栈的应用

1. 简单括号匹配

任务：对括号左右对应匹配，构造一个括号匹配算法。从左到右扫描括号，最新打开的左括号，应该匹配最先遇到的右括号 

流程图：

 代码：

from Stack import Stack
def parChecker(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 = index + 1
    if balanced and s.isEmpty():
        return True
    else:
        return False
print(parChecker('((()))))'))
print(parChecker('(((())))'))

[OUT]：
1 False
True

Process finished with exit code 0

但是在实际应用中，括号往往比较复杂，比如{}()[]：

代码：

from Stack import Stack
def parChecker2(symbolString):
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol in "({[":
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced = False
            else:
                top = s.pop()
                if not matches(top,symbol):
                    balanced = False
        index = index + 1
    if balanced and s.isEmpty():
        return True
    else:
        return False
def matches(open,close):
    opens = '({['
    closers = ')}]'
    return opens.index(open) == closers.index(close) #匹配open和close在opens和closers中的位置索引是否相等
print(parChecker2('{{([][])}()}'))
print(parChecker2('[{()}'))

[out]
E:ProgramsPythonPython38python.exe "F:/yesheng/DATA/code/data struct/parchecker.py"
True
False

Process finished with exit code 0

参考：https://www.bilibili.com/video/BV1QJ411w7bB?p=17

         2. 进制转换

1）十进制转换为二进制：除2取余

from Stack import Stack

def divideBy2(decNumber):
    '''
    次序反转
    :param decNumber: 十进制
    :return: 二进制
    '''
    remstack = Stack()

    while decNumber > 0:
        rem = decNumber % 2 #余数
        remstack.push(rem)
        decNumber = decNumber // 2 #整除数

    binString = ""
    while not remstack.isEmpty():
        binString = binString + str(remstack.pop())
    return binString
print(divideBy2(42))

[out]
E:ProgramsPythonPython38python.exe "F:/yesheng/DATA/code/data struct/jinzhi.py"
101010

Process finished with exit code 0

2)十进制转换为任意进制

def baseConverter(decNumber,base):
    '''
    十进制转换为十六以下任意进制
    :param decNumber:十进制
    :param base:目标N进制
    :return:转换结果
    '''
    digits = '0123456789ABCDEF'

    remstack = Stack()
    while decNumber > 0:
        rem = decNumber % base
        remstack.push(rem)
        decNumber = decNumber // base
    newString = ''
    while not remstack.isEmpty():
        newString = newString + digits[remstack.pop()]
    return newString
print(baseConverter(25,2))
print(baseConverter(25,16))

[OUT]
E:ProgramsPythonPython38python.exe "F:/yesheng/DATA/code/data struct/jinzhi.py"
11001
19

Process finished with exit code 0

         3.  表达式转换

 对于一些全括号表达式，移动操作符后和得到前缀和后缀表达式。

前缀和后缀表达式，操作符的次序决定运算的次序，离操作符近的先做，远的后做。

 看第一个，A+B*C+D，对于前缀表达式，首先与操作符最近的是*BC，所以，先做BC乘法，第二近的是+A，所以紧接着做A+B*C，最后是A+B*C+D，后缀表达式以此类推。

因此，将中缀表达式转换为前缀表达式和后缀表达式的思路是：先将中缀表达式转化为全括号的形式，然后将所有的操作符移动到子表达式所在的左括号（前缀）或者右括号（后缀）处，先替代括号，然后删除所有括号。

 这里介绍下通用的中缀表达式转后缀表达式算法：

在从左到右扫描逐个字符扫描中缀表达式的过程中，用一个Stack来暂时保存未处理的操作符，此时，栈顶的操作符就是最近暂存进去的，当遇到一个新的操作符，就需要跟栈顶的操作符比较下优先级，再进行处理。

例如：

( A * B ) + ( C * D )

from Stack import Stack

def infixTOPostfix(infixexpr):
    prec = {}
    #记录操作符的优先级
    prec['*'] = 3
    prec['/'] = 3
    prec['+'] = 2
    prec['-'] = 2
    prec['('] = 1
    opStack = Stack()
    postfixList = []
    tokenList = infixexpr.split() #将表达式转换成list

    for token in tokenList:
        if token in 'ABCDEFGHIJKLIMOPQRSTUVWXYZ' or token in '0123456789':
            postfixList.append(token) #元素直接保存
        elif token == '(':
            opStack.push(token)
        elif token ==')':
            topToken = opStack.pop()
            while topToken != '(':
                postfixList.append(topToken)
                topToken = opStack.pop()
        else:
            while (not opStack.isEmpty()) and (prec[opStack.peek()] >= prec[token]):
                postfixList.append(opStack.pop())
            opStack.push(token)
    while not opStack.isEmpty():
        postfixList.append(opStack.pop())
    return ''.join(postfixList)
s = "( A * B ) + ( C * D )"
print(infixTOPostfix(s))

[out]

AB*CD*+
Process finished with exit code 0

         4. 后缀表达式求值

问题：在对后缀表达式从左至右扫描过程中，由于操作符在操作数后面，因此要求后缀表达式形式的值，需要先暂存操作数，然后在碰到操作符的时候，再将暂存的操作数结合操作符进行实际计算。（仍然是栈的特性：操作符只作用于离它最近的两个操作数，最后入栈的最先计算）。

例子：4 5 6 * +

算法流程：先将 4 入栈，再将5入栈，接着将6入栈，然后将5 6 出栈进行乘法操作，将结果入栈，然后再将栈里面栈顶以及栈顶后面的元素做加法得到结果。

代码:

from Stack import Stack

def postfixEval(postfixExpr):
    operandStack = Stack()
    tokenList = postfixExpr.split()

    for token in tokenList:
        if token in '0123456789':
            operandStack.push(int(token))
        else:
            operand2 = operandStack.pop()
            operand1 = operandStack.pop()
            result = doMath(token,operand1,operand2)
            operandStack.push(result)
    return operandStack.pop()
def doMath(op, op1, op2):
    if op == '*':
        return op1 * op2
    elif op == '/':
        return op1 / op2
    elif op == '+':
        return op1 + op2
    elif op == '-':
        return op1 - op2
print(postfixEval('4 5 6 * +'))

[OUT]

34

Process finished with exit code 0