栈
栈(stack),有些地方称为堆栈,是一种容器,可存入数据元素、访问元素、删除元素,它的特点在于只能允许在容器的一端(称为栈顶端指标,英语:top)进行加入数据(英语:push)和输出数据(英语:pop)的运算。没有了位置概念,保证任何时候可以访问、删除的元素都是此前最后存入的那个元素,确定了一种默认的访问顺序。
由于栈数据结构只允许在一端进行操作,因而按照后进先出(LIFO, Last In First Out)的原理运作。
栈结构实现
栈可以用顺序表实现,也可以用链表实现。
栈的操作
- Stack() 创建一个新的空栈
- push(item) 添加一个新的元素item到栈顶
- pop() 弹出栈顶元素
- peek() 返回栈顶元素
- is_empty() 判断栈是否为空
- size() 返回栈的元素个数
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):
"""弹出元素"""
if self.is_empty():
return None
return self.items.pop()
def peek(self):
"""返回栈顶元素"""
if self.is_empty():
return None
return self.items[len(self.items)-1]
def size(self):
"""返回栈的大小"""
return len(self.items)
if __name__ == "__main__":
stack = Stack()
stack.push("hello")
stack.push("world")
stack.push("itcast")
print stack.size()
print stack.peek()
print stack.pop()
print stack.pop()
print stack.pop()
栈的应用
使用场景
1.符号匹配
2.计算机表达式的转换
3.CPU内部栈主要是用来进行子程序调用和返回
4.进制转换
括号匹配问题 大多数计算机语言中都需要检测括号是否匹配,那么如何实现符号成对检测?
算法思路:
-
从第一个字符开始扫描
-
当遇见普通字符时忽略
-
当遇见左符号时压入栈中
-
当遇见右符号时从栈中弹出栈顶符号,并进行匹配
-
匹配成功:继续读入下一个字符
-
匹配失败:立即停止,并报错
-
结束: 成功: 所有字符扫描完毕,且栈为空 失败:匹配失败或所有字符扫描完毕但栈非空
def match(str):
stack = Stack()
check_dict = {
')': '(',
']': '[',
'}': '{'
}
for char in str:
if char in {'(', '[', '{'}:
# 左括号压栈
stack.push(char)
elif char in {')', ']', '}'} and stack.size() > 0:
if stack.peek() == check_dict[char]:
stack.pop()
if stack.size() == 0:
return True
else:
return False
if __name__ == '__main__':
print(match('1(667)[]85{4}')) # True
print(match('({[]})')) # True
print(match('(])[')) # False
print(match('([]{}')) # False
计算机表达式转换 计算机的本质工作就是做数学运算,那计算机可以读入字符串 "9 + (3 - 1) * 5 + 8 / 2"并计算值吗?
中缀表达式和后缀表达式
后缀表达式(由波兰科学家在20世纪50年代提出) 将运算符放在数字后面 ===》 符合计算机运算
我们习惯的数学表达式叫做中缀表达式===》符合人类思考习惯 实例
5 + 4 => 5 4 + 1 + 2 * 3 => 1 2 3 * + 8 + ( 3 - 1 ) * 5 => 8 3 1 - 5 * +
算法思路 中缀转后缀: 遍历中缀表达式中的数字和符号
练习拓展: 中缀转后缀
- 遍历中缀表达式中的数字和符号
对于数字:直接输出
对于符号:
(4)遍历结束:将栈中的所有符号弹出并输出
(1)左括号:进栈
(2)运算符号:与栈顶符号进行优先级比较
若栈顶符号优先级低:此符号进栈 (默认栈顶若是左括号,左括号优先级最低)
若栈顶符号优先级不低:将栈顶符号弹出并输出,之后进栈
(3)右括号:将栈顶符号弹出并输出,直到匹配左括号
def pri_to_back(str):
stack = Stack()
dict_priority = {'*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
str2 = []
for i in str:
if i.isdigit():
# 数字直接添加
str2.append(i)
elif i == '(':
# 左括号
stack.push(i)
elif i == ')':
# 右括号
while stack.peek() != '(' and stack.size() > 0:
str2.append(stack.pop())
stack.pop()
else:
# 运算符号
if not stack.is_empty():
# 判断栈是否为空,空直接压栈
level = dict_priority.get(i)
peek_level = dict_priority.get(stack.peek(), 0)
while level <= peek_level:
# 判断运算符与栈顶元素的优先级高低,运算符优先级高则不进入循环直接压栈
# 运算符优先级低则依次弹出比它优先级大或等于它优先级的元素
str2.append(stack.pop())
peek_level = dict_priority.get(stack.peek(), 0)
stack.push(i)
while not stack.is_empty():
str2.append(stack.pop())
return ' '.join(str2)
if __name__ == '__main__':
print(pri_to_back('5+4')) # 5 4 +
print(pri_to_back('1+2*3')) # 1 2 3 * +
print(pri_to_back('8+(3-1)*5')) # 8 3 1 - 5 * +
练习拓展:计算机如何基于后缀表达式结算结果 例如:8 3 1 - 5 * +
计算规则:
遍历后缀表达式中的数字和符号
对于数字:进栈
对于符号: (1)从栈中弹出右操作数 (2)从栈中弹出左操作数 (3)根据符号进行运算 (4)将运算结果压入栈中
遍历结束:栈中的唯一数字为计算结果
def cal_from_back(str):
stack = Stack()
dict_cal = {
'+': lambda x, y: x + y,
'-': lambda x, y: x - y,
'*': lambda x, y: x * y,
'/': lambda x, y: x / y,
}
for i in str:
if i.isdigit():
stack.push(i)
else:
right = int(stack.pop())
left = int(stack.pop())
outcome = dict_cal[i](left, right)
stack.push(outcome)
return stack.pop()
if __name__ == '__main__':
print(cal_from_back('54+')) # 9
print(cal_from_back('123*+')) # 7
print(cal_from_back('831-5*+')) # 18
队列
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。
队列是一种先进先出的(First In First Out)的线性表,简称FIFO。允许插入的一端为队尾,允许删除的一端为队头。队列不允许在中间部位进行操作!假设队列是q=(a1,a2,……,an),那么a1就是队头元素,而an是队尾元素。这样我们就可以删除时,总是从a1开始,而插入时,总是在队列最后。这也比较符合我们通常生活中的习惯,排在第一个的优先出列,最后来的当然排在队伍最后。
队列的实现
同栈一样,队列也可以用顺序表或者链表实现。
操作
- Queue() 创建一个空的队列
- enqueue(item) 往队列中添加一个item元素
- dequeue() 从队列头部删除一个元素
- is_empty() 判断一个队列是否为空
- size() 返回队列的大小
class Queue(object):
"""队列"""
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def enqueue(self, item):
"""进队列"""
self.items.insert(0,item)
def dequeue(self):
"""出队列"""
if self.is_empty():
return None
return self.items.pop()
def size(self):
"""返回大小"""
return len(self.items)
if __name__ == "__main__":
q = Queue()
q.enqueue("hello")
q.enqueue("world")
q.enqueue("itcast")
print q.size()
print q.dequeue()
print q.dequeue()
print q.dequeue()
双端队列
双端队列(deque,全名double-ended queue),是一种具有队列和栈的性质的数据结构。
双端队列中的元素可以从两端弹出,其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。
操作
- Deque() 创建一个空的双端队列
- add_front(item) 从队头加入一个item元素
- add_rear(item) 从队尾加入一个item元素
- remove_front() 从队头删除一个item元素
- remove_rear() 从队尾删除一个item元素
- is_empty() 判断双端队列是否为空
- size() 返回队列的大小
实现
class Deque(object):
"""双端队列"""
def __init__(self):
self.items = []
def is_empty(self):
"""判断队列是否为空"""
return self.items == []
def add_front(self, item):
"""在队头添加元素"""
self.items.insert(0,item)
def add_rear(self, item):
"""在队尾添加元素"""
self.items.append(item)
def remove_front(self):
"""从队头删除元素"""
if self.is_empty():
return None
return self.items.pop(0)
def remove_rear(self):
"""从队尾删除元素"""
if self.is_empty():
return None
return self.items.pop()
def size(self):
"""返回队列大小"""
return len(self.items)
if __name__ == "__main__":
deque = Deque()
deque.add_front(1)
deque.add_front(2)
deque.add_rear(3)
deque.add_rear(4)
print deque.size()
print deque.remove_front()
print deque.remove_front()
print deque.remove_rear()
print deque.remove_rear()
队列的应用
1.windows中的消息机制就是通过队列来实现的
2.操作系统的进程、作业管理中的先进先出服务
3.异步消息机制,如celery异步任务
约瑟夫斯问题(热土豆游戏)
这场比赛是一个现代的相当著名的约瑟夫斯问题。基于对第一世纪著名历史学家Flavius Josephus的传说,故事说的是,在对罗马犹太人起义,约瑟夫斯和39名战友顶住了罗马人在一个山洞里。随着失败迫在眉睫,他们决定,他们宁愿死也不愿做罗马人的奴隶。他们安排自己在一个圆圈里。一个人被划为第一号,顺时针方向,每第七个男人就杀了一个。约瑟夫斯,根据传说,是一个有成就的数学家。他立刻想出了他应该坐的地方是最后一个去的地方。当时间来了,而不是杀死自己,他加入了罗马的一边。
打印机任务(拓展不要求会)
图书馆中有一台打印机,打印机有两种工作模式:每分钟10页(但打印质量较低),每分钟5页(打印效果较好)。打印机一次只能处理一个任务,其余任务可排队等候。 每个小时最多有10位学生在图书馆,他们在一小时终最多提交2次打印任务,每个打印任务的页数为1至20页不等。 问:综合分析两种打印模式,分析学生的平均等待打印时间和是否能在1小时内完成所有学生提交的打印任务
双端队列应用
一个有趣的问题,可以很容易地解决了使用队列的数据结构是典型的回文问题。回文数是一个字符串,读取相同的向前和向后的,例如,"sbbs"我们想构造一个算法,输入一个字符串是否回文。这个问题的解决方案将使用一个队列来存储字符串的字符。我们将从左到右弦和添加的每个字符的双端队列后。在这一点上,deque将会表现的非常像一个普通的队列。然而,我们现在可以利用该容器的双重功能。该容器前将字符串和该容器后的第一个字符将举行的最后一个字符