数据结构学习笔记（python）——栈

一.定义：有序集合，添加操作和移除操作发生在同一端，排序原则为LIFO（后进先出）

二.栈抽象数据类型：

Stack( )    #创建一个空栈。无需参数，且会返回一个空栈

push(item)  #将一个元素添加到栈的顶端，需要一个参数item，且无返回值

pop( )      #将栈顶端的元素删除。无需参数，但会返回顶端的元素，且修改栈的内容

peek( )     #返回栈顶端的元素，但不删除元素。无需参数，也不修改栈的内容

isEmpty( )  #检查栈是否为空。无需参数，且返回一个bool值

size( )     #返回栈中元素的数目。无需参数，且返回一个整数

三.用Python实现栈

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)

注： 列表尾部作为栈的顶部的实现，对append方法和pop方法的时间复杂度都是O(1）

例：匹配括号‘（ ）’

        描述：从左到右读取一个括号串，然后判断其中的括号是否匹配（当从左到右处理括号时，最右边的无匹配左括号必须和接下来遇到的第一个右括号相匹配，并且第一个位置的左括号可能需要等到处理到最后一个位置的右括号才能匹配） 

        思路：由一个空栈开始，由左至右依次处理括号，如果遇到左括号，则利用push方法加入栈，如果遇到右括号，则利用pop方法；只要栈中的所有左括号都有右括号匹配，整个括号串就是匹配的，处理完之后栈为空栈

# 匹配括号
from zhan.python_basic 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 += 1

    if balanced and s.isEmpty():
        return True
    else:
        return False

例：匹配符号‘（ [ { } ] ）’

        描述：和单独的括号相比，区别在于当出现右符号时，必须检测其类型是否和栈顶的左符号类型相匹配

# 匹配符号
from zhan.python_basic import Stack

def parChecker(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 += 1

    if balanced and s.isEmpty():
        return True
    else:
        return False

def matches(open, close):
    opens = '([{'
    closers = ')]}'

    return opens.index(open) == closers.index(close)

例：将十进制转化成二进制

        思路：利用一种‘除以2’的算法，该算法使用栈来保存二进制结果的每一位（注：利用该方法，栈的元素输出顺序为顶部到底部）

# 十进制——二进制的转化
from zhan.python_basic import Stack


def divideBy2(decNumber):
    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

例：前序、中序和后序表达式

    

 1.从中序向前序和后序转换

        思路：首先使用完全括号表达式，例如将A+B*C写作（A+(B*C)）,若转化为后序则将运算符移动到右括号对应的位置，反之亦然

 

 2.从中序到后序的通用转换方法

        思路：

        1）创建用于保存运算符的空栈opstack，和一个用于保存结果的空列表

        2）利用split函数将输入的中序表达式转换成一个列表

        3）自左向右扫描这个标记列表

        3.1.如果标记是操作数，将其添加到结果列表的末尾

        3.2.如果标记是左括号，将其压入opstack栈中

        3.3.如果标记是右括号，反复从opstack栈中移除元素，直到移除对应的左括号。将从栈中取出的每一个运算符都添加到结果列表的末尾

        3.4.如果标记是运算符，将其压入opstack栈中。在此之前，需要从栈中取出优先级更高或相同的运算符，并将它们添加到结果列表的末尾

# 中序到后序的通用转换方法
from zhan.python_basic import Stack
import string

def infixToPostfix(infixexpr):
    prec = {}
    prec["*"] = 3
    prec["/"] = 3
    prec["+"] = 2
    prec["-"] = 2
    prec["("] = 1

    opStack = Stack()
    postfixList = []
    tokenlist = infixexpr.split()
    for token in tokenlist:
        if token in string.ascii_uppercase:
            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)

3.计算后序表达式

        思路：

        1.创建空栈operandStack

        2.使用字符串方法split将输入的后序表达式转换成一个列表

        3.从走往右扫描列表

        3.1.如果标记是操作数，转换成整数并压入operandStack栈中

        3.2.如果标记是运算符，从 operandStack栈中取出两个操作数（注：由于除法运算中有顺序问题，因此对所有的运算符，步骤均为第一次取出右操作数，第二次取出左操作数）

# 计算后序表达式
from zhan.python_basic 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