1.Python数据结构及算法----栈

栈（有时称为“后进先出栈”）是一个项的有序集合，其中添加移除新项总发生在同一端。这一端通常称为“顶部”。与顶部对应的端称为“底部”。

栈的底部很重要，因为在栈中靠近底部的项是存储时间最长的。最近添加的项是最先会被移除的。这种排序原则有时被称为 LIFO，后进先出。它基于在集合内的时间长度做排序。较新的项靠近顶部，较旧的项靠近底部。

1.实现栈的各项功能

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度


if __name__ == '__main__':
    s = StackTest()

    print(s.isEmpty())
    s.push(4)
    s.push('dog')
    print(s.peek())
    s.push(True)
    print(s.size())
    print(s.isEmpty())
    s.push(8.4)
    print(s.pop())
    print(s.size())
    print(s.items)

2.利用栈检查圆括号是否正确，是否成对出现

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度

# 检查圆括号是否正确
def parCheck(symbolString):
    s = StackTest()
    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 s.isEmpty() and balanced:
        return True
    else:
        return False

if __name__ == '__main__':
    print(parCheck('((()))'))
    print(parCheck('(()'))
    print(parCheck(')()'))
    print(parCheck(')('))

3.在上述语句中，稍加改动，检查不同括号出现的情况

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度

# 检查圆括号是否正确
def parCheck(symbolString):
    s = StackTest()
    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 s.isEmpty() and balanced:
        return True
    else:
        return False


def matches(open, close):
    opens = '([{'
    closes = ')]}'
    return opens.index(open) == closes.index(close)

if __name__ == '__main__':
    print(parCheck('[{()]'))
    print(parCheck('([])'))
    print(parCheck('{{([][])}()}'))

4.利用栈将十进制转换为二进制

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度



# 十进制转二进制
def dividedBy2(dec_number):
    remstack = StackTest()
    while dec_number>0:
        rem = dec_number%2
        remstack.push(rem)
        dec_number =  dec_number // 2

    binstring = ''
    while not remstack.isEmpty():
        binstring = binstring  + str(remstack.pop())

    return binstring

if __name__ == '__main__':
    print(dividedBy2(10))

4.利用栈将十进制扩展为转换不同进制的数

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度


# 十进制转其他进制(二进制、八进制、十六进制等)
def baseConvertor(dec_number, base):
    digits = '0123456789ABCDEF'

    remstack = StackTest()
    while dec_number > 0:
        rem = dec_number % base
        remstack.push(rem)
        dec_number = dec_number // base

    binString = ''
    while not remstack.isEmpty():
        binString = binString + digits[remstack.pop()]

    return binString

if __name__ == '__main__':
    print(baseConvertor(233, 16))

5.计算中缀转为后缀

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度


# 中缀转后缀表达式
def infixToSuffix(inifixexpr):
    prep = {}
    prep['*'] = 3
    prep['/'] = 3
    prep['+'] = 2
    prep['-'] = 2
    prep['('] = 1

    opStack = StackTest()
    suffixList = []
    markList = inifixexpr.split()

    for mark in markList:
        if mark in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' or mark in '0123456789':
            suffixList.append(mark)
        elif mark == '(':
            opStack.push(mark)
        elif mark == ')':
            topMark = opStack.pop()
            while topMark != '(':
                suffixList.append(topMark)
                topMark = opStack.pop()
        else:
            while (not opStack.isEmpty()) and (prep[opStack.peek()] >= prep[mark]):
                suffixList.append(opStack.pop())
            opStack.push(mark)

        print(suffixList)

    while not opStack.isEmpty():
        suffixList.append(opStack.pop())
        print(suffixList)
    return ' '.join(suffixList)

if __name__ == '__main__':
    print(infixToSuffix('( A + B * D ) * C'))

6.计算后缀表达式

# 实现栈功能
class StackTest:
    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[-1] # 返回最后一个元素

    def size(self):
        return len(self.items) # 返回栈的长度

# 进行数据计算
def doMath(op, op1, op2):
    if op == '*':
        return  op1 * op2
    elif op == '/':
        return  op1 / op2
    elif op == '+':
        return op1 + op2
    else:
        return op1 - op2

def suffixEval(suffixexpr):
    oprandStack = StackTest()
    markList = suffixexpr.split()

    for mark in markList:
        if mark in '0123456789':
            oprandStack.push(int(mark))
        else:
            oprand2 = oprandStack.pop()
            oprand1 = oprandStack.pop()
            result = doMath(mark, oprand1, oprand2)
            oprandStack.push(result)
    return result


if __name__ == '__main__':
    print(suffixEval('7 9 + 3 5 + /'))