python 栈 计算器 python栈应用

【Python数据结构1】栈的应用

栈Stack：什么是栈？

❖一种有次序的数据项集合，在栈中，数据项的加入和移除都仅发生在同一端

这一端叫栈“顶top”，另一端叫栈“底base”

❖日常生活中有很多栈的应用，如：盘子、托盘、书堆等等

❖距离栈底越近的数据项，留在栈中的时间就越长，而最新加入栈的数据项会被最先移除

❖这种次序通常称为后进先出LIFO：Last in First out

这是一种基于数据项保存时间的次序，时间越短的离栈顶越近，而时间越长的离栈底越近

❖❖❖抽象数据类型“栈”定义为如下的操作:

Stack()：创建一个空栈，不包含任何数据项

push(item)：将item加入栈顶，无返回值

pop()：将栈顶数据项移除，并返回，栈被修改

peek()：“窥视”栈顶数据项，返回栈顶的数据项但不移除，栈不被修改

isEmpty()：返回栈是否为空栈

size()：返回栈中有多少个数据项

抽象数据类型Stack：操作样例

另外

python列表（list）就具有栈的特性，其函数与栈中相对应的函数功能类似，故可以直接把list当做栈来使用，也可以利用list构建Stack类

栈代码示例

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)

示例1：进制转换

直接使用list做为栈

def HexConv(decNumber,base):
	dights=[str(i) for i in range(10)]+[chr(i) for i in range(65,72)]
	remstack=[]
	while decNumber>0:
		rem=decNumber%base
		remstack.append(dights[rem])
		decNumber//=base
	res=""
	while remstack!=[]:
		res+=remstack.pop()
	return res

if __name__ == '__main__':
	n=int(input("请输入原数:"))
	hex=int(input("目标进制："))
	print("十进制{}转换为{}进制结果:{}".format(n,hex,HexConv(n,hex)))

示例2：括号匹配

引入Stack类

from stack_set import Stack

def bracMatch(bracketItem):
	bracketList = list(bracketItem)
	braStack = Stack()
	leftbrac = "{[("
	rightbrac = "}])"
	result = True
	for item in bracketList:
		if item in leftbrac:
			braStack.push(item)
		elif item in rightbrac:
			if braStack.isEmpty():
				result = False
			else:
				# peek函数取栈顶元素，判断栈顶元素是否跟右括号相对应
				if matchBoth(braStack.peek(), item):
					braStack.pop()
				else:
					result = False

	if braStack.isEmpty() and result:
		result = True
	else:
		result = False
	return result

def matchBoth(item1, item2):
	leftbrac = "{[("
	rightbrac = "}])"
	return leftbrac.index(item1) == rightbrac.index(item2)

if __name__ == "__main__":
	str = input("请输入表达式")
	if bracMatch(str):
		print("括号匹配")
	else:
		print("括号不匹配")

示例3：中缀表达式转为后缀表达式

from stack_set import Stack

def infixToPostfix(infixpr):
	pre={}
	pre['*'],pre['/']=3,3
	pre['+'],pre['-']=2,2
	pre['(']=1
	charlist=[chr(i) for i in range(65,91)]
	numlist=[i for i in range(10)]
	# 生成一个用于存储符号的栈和一个用于存储值的列表
	opstack=Stack()
	postfixlist=[]
	items=infixpr.split()
	for item in items:
		# 判断是否为表达式中的值
		if item in charlist or item in numlist:
			postfixlist.append(item)
		elif item=="(":
				opstack.push(item)
		elif item==')':
			tokentop=opstack.pop()
			while tokentop!="(":
				postfixlist.append(tokentop)
				tokentop=opstack.pop()
		else:
			# 当栈非空时，入栈的符号要先检查其是否满足入栈优先级
			while(not opstack.isEmpty()) and (pre[item]<=pre[opstack.peek()]):
				postfixlist.append(opstack.pop())
			opstack.push(item)
			print("stack:{},postlist:{}".format(opstack.items,postfixlist))
	# 最后将栈中元素出栈（进栈前已考虑优先级，出栈直接出）
	while not opstack.isEmpty():
		postfixlist.append(opstack.pop())

	return "".join(postfixlist)
if __name__ == '__main__':
	infix="A + ( B * C )"
	postfix=infixToPostfix(infix)
	print("其对应的后缀表达式：{}".format(postfix))

读者可自行体会直接使用list与构建stack的区别