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 + /'))