Python 数据结构 —— Stack

1. list

Python 内置的 list 类对象的使用很灵活,可以方便地访问修改列表元素:

method description
L.append(x) 在 L 尾部添加元素 x
L.pop(i) 删除位置 i 处的元素并返回,相当于 del L[i],i 默认为 i=len(L)-1
L.insert(i, x) 在位置 i 处插入元素 x
L.remove(x) 删除第一个值为 x 的元素,不存在则报错
L.count(x) 返回元素 x 出现的次数
L.sort() 就地排序
L.reverse() 就地逆序
L.clear() 清空列表,相当与 del list[:]

通过 del 可以方便的删除元素,如 del L[2]del L[1: 5],如果要删除整个列表,可以:

del L[:]

但不能 del L 因为这样只是删除了列表的引用,而列表对应的内存空间仍然存在,只是无法访问了:

a = [0, 1, 2, 3, 4]
c = a
del a
print(c)	# [0, 1, 2, 3, 4]


2. Stack

2.1 Stack 类方法

Stack 类具有以下方法:

  • push()
  • pop()
  • peek()
  • size()
  • isEmpty()

其中,pop() 是弹栈操作,返回栈顶元素,peek() 只是返回栈顶元素值,不弹栈!


2.2 利用 list 构建 Stack

创建一个文件夹 DataStructures, 在其中创建文件 DataStructures.py,在其中定义类:

class Stack:
	def __init__(self):
		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)

	def isEmpty(self):
		return self.items == []

if __name__ == '__main__':
	s = Stack()
	for i in range(5):
		s.push(i)
	while not s.isEmpty():
		print(s.pop())

打印结果为:

4
3
2
1
0

在外部调用 Stack 可以通过下面的命令引入:

from DataStructures.Stack imort Stack


3. 使用 Stack

2.1 括号匹配问题

问题描述:判断一组括号是否匹配,如 (()((())())) 是匹配的,而 (()() 是不匹配的:

from DataStructures.Stack import Stack

def parChecker(symbolString):
	s = Stack()
	for symbol in symbolString:
		if symbol == '(':
			s.push(symbol)
		else:
			if s.isEmpty():
				return False
			if s.pop() == '(':
				continue
			else:
				return False
	if s.isEmpty():
		return True
	else:
		return False

print(parChecker('(()((())()))'))

3.2 进制转换问题

问题描述:利用程序实现将一个十进制数转换为二进制数的函数
解题思路:对十进制数反复对 2 取余和整除 2 的操作,将结果压栈,最后全部弹栈:

from DataStructures.Stack import Stack

def DecimalToBinary(number):
	s = Stack()
	while number:
		res = number % 2
		number = (number - res) // 2
		s.push(res)
	ans = ''
	while not s.isEmpty():
		ans = ans + str(s.pop())
	return ans

print(DecimalToBinary(13))

打印结果为 1101 ,正确


3.3 中序表达式转换

问题描述
中序表达式是我们日常所见表达式的顺序,如
a * b + c * d
a * (b + c) * d
但是这种表达式需要用括号用来辅助计算顺序,而前序表达式和后序表达式不需要括号,后序表达式的定义为运算符在两个操作数之后的表达式,如上面两个表达式对应的后序表达式为:

a * b + c * d     =>    a b * c d * +
a * (b + c) * d   =>    a b c + * d *

解题思路:

  • 首先去掉输入表达式中所有空格
  • 创建一个栈,用来存储运算符
  • 对表达式中每一个字符进行处理
  • 如果当前字符为数字,则打印字符
  • 如果当前字符为运算符
    若栈顶操作符优先级比当前运算符高或相同,则弹栈并打印
    将当前字符压栈
  • 如果当前字符为括号,左括号入栈,若为右括号,则将栈内括号元素后的所有元素弹栈
from DataStructure.Stack import Stack

def midToPostCalculate(expression):
	res = ''
	s = Stack()
	expression = ''.join(expression.split(' '))
	for item in expression:
		# number
		if item not in list('+-*/()'):
			res += item

		# operator
		elif item in list('+-*/'):
			priority = {'*': 2, '/': 2, '+': 1, '-': 1, '(': 0}
			if not s.isEmpty() and priority[s.peek()] >= priority[item]:
				res += s.pop()
			s.push(item)

		# embraces
		elif item in list('()'):
			if item == '(':
				s.push(item)
			elif item == ')':
				while s.peek() != '(':
					res += s.pop()
				s.pop()

	while not s.isEmpty():
		res += s.pop()
	return res

测试结果:

expression = '(A + B) * C - (D - E) * (F + G)'
print(midToPostCalculate(expression))	# AB+C*DE-FG+*-


完结

你可能感兴趣的:(Python,数据结构与算法,栈,python)