数据结构python版（二）栈

1、线性结构Linear Structure
线性结构是一种有序数据项的集合，其中每个数据项都有唯一的前驱和后继。
不同线性结构的区别在于数据项增减的方式。
2、栈Stack
在栈里数据项的加入和移除都在同一端，也是线性结构的一种，最新加入的会被最新移除，例如盘子，一堆书等，浏览器的后退按钮，word中的撤销操作。
(1)操作方法
Stack():创建一个空栈，不包含任何数据项
push(item):将item加入栈，无返回值
pop():将栈顶数据项移除，并返回，栈被修改
peek():窥视栈顶数据项，返回栈顶的数据项但不移除
isEmpty()：返回栈是否为空栈
size()：返回栈中数据项个数
栈可以放各种类型的数据
(2)如何实现栈
通过class借由列表来定义
可以将List的任意一端设置为栈顶(index=0或-1)

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)

通向也可以把列表的第一位作为栈顶，此时push/pop的复杂度为O(n),而原方法相应操作的复杂度为O(1)

class Stack:
    def __init(self):
        self.items=[]
    def isEmpty(self):
        return self.items ==[]
    def push(self,item):
        self.items.insert(0,item)
    def pop(self):
        return self.items.pop(0)
    def peek(self):
        return self.items[0]
    def size(self):
        return len(self.items)

(3)应用：简单括号匹配
目标是检测左右括号是否互相匹配
从左到右扫描括号串，打开最新的左括号应该匹配到最先遇到的右括号，这样第一个打开的左括号会匹配最后一个右括号。
代码示例

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

多种括号类型匹配同理([)]也是不匹配的

from pythonds.basic.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:
                top=s.pop()
                if not matches(top,symbol):
                   balanced=False
        index +=1
    if balanced and s.isEmpty():
        return True
    else:
        return False
def mathches(open,close):
    opens="([{"
    closers=")]}"
    return opens.index(open) == closers.index(close)
print(parChecker('((()))'))
print(parChecker('(()'))

(4)应用：十进制转换为二进制
连续除以二是得到的是从低到高的位数，但是输出是从高位到低位，需要用栈反转输出

from pythonds.basic.stack 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
print(divideBy2(42))

十进制转换为任意进制

from pythonds.basic.stack import Stack
def divideBy2(decNumber,base):
   digits="0123456789ABCDEF"
   remstack=Stack()
   while decNumber>0:
       rem=decNumber % base
       remstack.push(rem)
       decNumber = decNumber //base
   binString =""
   while not remstack.isEmpty():
       binString = binString +digits[remstack.pop()]
   return binString
print(divideBy2(42))

(5) 表达式转换
前缀与后缀表达式：操作符相对于两个数字的位置
eg:a+bc 可以变为+abc 或abc*+
在前缀和后缀表达式中操作符的次序完全决定了运算的次序

全括号的中缀表达式变成前缀或后缀
eg (bc)用代替(的位置并删去)，即生成前缀表达式，相反是后缀表达式
故先把中缀表达式换为全括号形式，再进行相应的变化。
在转换过程中操作符要比操作数晚输出，古要先把操作符保存，但由于优先级规则，操作符可能要反转次序输出eg: a+bc 后缀为abc+，+在前面却要后输出，因此用栈保存。
而遇到左括号时，先标记一下，其后出现的操作符的优先级提升了，一旦扫描到对应的右括号，就可以马上输出这个操作符了。
约定中缀表达式是由空格隔开的一系列单词(token)构成，其中操作符单词包括/-+()，而操作单词则是单字母标识符A,B,C等。
(a)先创建空栈opstack用于暂存操作符，空表postfixList用于保存后缀表达式
(b)将中缀表达式转换为单词(token)列表
eg: A+BC =split=>[‘A’,’+’,‘B’,’’,‘C’]
©从左到右扫描中缀表达式单词列表
if单词是操作数，则直接添加到后缀表达式列表的末尾
如果单词是左括号，则压入opstack栈顶
如果单词是右括号，则反复弹出opstack栈顶操作符，加入到输出列表的末尾，知道碰到左括号
如果单词是操作符*/-+，则压入opstack栈顶，这里在压入前要比较其与栈顶操作符的优先级，如果栈顶的高于或等于它，则要反复弹出栈顶操作符，加入到输出列表的末尾，直到栈顶的操作符优先级低于它。
(d)扫描结束后把opstack里剩下的依次弹出，添加到末尾。
(e)把输出列表再用join方法合并成后缀表达式字符串，算法结束。
代码如下：

from pythonds.basic.stack import Stack
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 "AQWERTYUIOPSDFGHJKLZXCVBNM" or token in "1234567890":
        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 \
            (prex[opStack.peek()] >= prec[token]):
                postfixList.append(opStack.pop())
        opStack.push(token)
    while not opStack.isEmpty():
        postfixList.append(opStack.pop())
    return "".join(postfixList)     

(6)后缀表达式求值
关键是操作符在操作数的后面，所以要先存操作数，有了操作符后再进行计算。仍然是栈的特性，操作符只作用于离它最近的两个数。这里需要注意先出栈的是右操作数，中间结果作为操作数还要继续压入栈中，最后只留一个数

from pythonds.basic.stack import Stack
def postfixEval(postfixExpr):
    opStack=Stack()
    tokenList=postfixExpr.split()
    #扫描
    for token in tokenList:
        if token in "1234567890":
            opStack.push(int(token))
        else:
            oper2=opStack.pop()
            oper1=opStack.pop()
            result=doMath(token,oper1,oper2)
            opStack.push(result)
    return opStack.pop()  
def doMath(op,op1,op2):
    if op="*":
        return op1*op2
    elif op="/":
        return op1/op2
    elif op="+":
        return op1+op2
    else:
        return op1-op2