数据结构与算法(python)-------------栈的操作

栈-------基本操作

class Stack(object):
    """栈"""

    def __init__(self):
        self.items = []

    def is_empty(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)

if __name__ == "__main__":
    stack = Stack()
    # 先给栈中添加一个元素
    stack.push("我是谁1")
    stack.push("我是谁2")
    stack.push("我是谁3")
    # 求出栈的长度
    print(stack.size())
    # 求出栈顶端的元素也就是最后一个元素
    print(stack.peek())
    # 删除栈顶端元素，就是删除最后一个元素
    print(stack.pop())
    # 判断栈是否为空
    print(stack.is_empty())

栈------匹配括号

from pythonds.basic.stack import Stack

"""
1、先建立一个空栈 s
2、设一个为True的变量 balanced
3、定义一个为0的int对象 index
4、求传来的参数长度大于0，且balanced为true
5、先求参数的第零个索引，如果这个索引为"(" 就放入栈中，
                     如果不是"(",就判断栈s是否为空
                        如果为空，就另balanced变量为False
                        不为空，就删除栈顶的元素，
                    然后在判断第二个索引值，就要给index加上1
                全部遍历完后，判断balanced是否为true和栈s是否为空
                如果两者都成立，则返回true
                不成立，则返回false
"""


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('((((()))))))'))
print(parChecker('((()))'))
str = "123456789"

if str[2] in '356589':
    print("包含")
else:
    print("不包含")

print(str.index("5"))

栈-------十进制转二进制

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 += str(remstack.pop())
    return binString


print(divideBy2(1))

栈-------十进制转十六进制

from pythonds.basic.stack import Stack

def baseConverter(decNumber,base):
    digits = "0123456789ABCDEF"
    remstack = Stack()
    while decNumber > 0 :
        rem = decNumber % base
        remstack.push(rem)
        decNumber = decNumber // base

    newString = ""
    while not remstack.isEmpty():
        newString += digits[remstack.pop()]
    return newString
print(baseConverter(25652365,2))
print(baseConverter(25652365,16))

栈-------后缀表达式

from pythonds.basic.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()
    return operandStack.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

栈-------表达式转换

from pythonds.basic.stack import Stack


def infixToPosfix(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 "ABCDEFGHIJKLMNOPQRSTUVWXTZ" 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)


print(infixToPosfix("7*(8-2)+1*9"))

栈-------通用括号匹配算法

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 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 = "([{"
    closes = ")]}"
    return opens.index(open) == closes.index(close)


print(parChecker('{[()]}'))