数据结构--列表，栈，队列
学习目标：
1.了解什么是数据结构
2.列表
3.栈
4.队列
数据结构：
数据结构是指相互之间存在着-种或多种关系的数据元素的集合和该集
合中数据元素之间的关系组成。
简单来说，数据结构就是设计数据以何种方式组织并存储在计算机中。
比如:列表、集合与字典等都是一种数据结构。
N.Wirth:“程序=数据结构+算法”
数据结构按照其逻辑结构可分为线性结构、树结构、图结构
线性结构:数据结构中的元素存在一-对一的相互关系
树结构:数据结构中的元素存在一对多的相互关系
图结构:数据结构中的元素存在多对多的相互关系
列表：
列表(其他语言称数组)是一种基本数据类型。
关于列表的问题:
1.列表中的元素是如何存储的?
2.列表的基本操作:按下标查找、插入元素、删除元素…
这些操作的时间复杂度是多少?
扩展: Python的列表是如何实现的?
数组与列表有两点不同:
1.数组元素类型要相同
2.数组长度固定
1.列表是顺序存储；2.O(n)
列表就是最简单的线性结构，大家都了解列表，就不详细介绍。
栈：
栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。
栈的特点:后进先出LIFO (last-in, frst-out)
栈的概念:栈顶、栈底
栈的基本操作:
进栈(压栈) : push
出栈: pop
取栈顶: gettop
class stack:
def __init__(self):
self.stack = []
def push(self, element):
self.stack.append(element)
def pop(self):
return self.stack.pop()
def get_top(self):
if len(self.stack) > 0:
return self.stack[-1]
else:
return None
def is_empty:
return len(self.stack) == 0
使用一般的列表结构即可实现栈
进栈: li.append
出栈: li.pop
取栈顶: li[-1]
栈的应用 – 括号匹配问题：
括号匹配问题:给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。
def brace_match(s):
match = {'}':'{', ']':'[',')':'('}
stack = Stack()
for ch in s:
if ch in {'(', '[', '{'}:
stack.push(ch)
elif: # ch in {'}',']',')'}
if stack.is_empty():
return False
elif stack.get_top() == match[ch]:
stack.pop()
else: # stack.get_top() != match[ch]
return False
if stack.is_empty():
return True
else:
return False
print(brance_match('[][][]{}()(){}'))
队列：
队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另- 端进行删除。
进行插入的一端称为队尾(rear),插入动作称为进队或入队
进行删除的一端称为队头(front)， 删除动作称为出队
队列的性质:先进先出(First-in, First-out)
环形队列： 当队尾指针front == Maxsize + 1,再前进一个位0
队首指针前进1 front = (front + 1) % MaxSize
队尾指针前进1 rear = （rear + 1) % MaxSize
队空条件 rear == front
对满条件 (rear + 1) % MaxSize == front
队列能否用列表简单实现？为什么？
Class Queue:
def __init__(self, size=100):
self.queue = [0 for _ in range(size)]
self.rear = 0 # 队尾 进队
self.front = 0 # 队首 出队
def push(self, element):
if not self.is_filled():
self.rear = (self.rear+1)%self.size
self.queue[self.rear] = element
else:
raise IndexError("Queue is filled")
def pop(self):
if not self.is_empty():
self.front = (self.front+1)%self.size
return self.queue[self.front]
else:
raise IndexError("Queue is empty.")
def is_empty(self):
return self.rear == self.front
def is_filled(self):
return (self.rear+1)%self.size = self.front
q = Queue(5)
for i in range(4):
q.push(i)
print(q.is_filled())
队列的内置模块
双向队列的两端都支持进队和出队操作
双向队列的基本操作:
队首进队
队首出队
队尾进队
队尾出队
使用方法: from collections import deque
创建队列: queue = deque()
进队: append()
出队: popleft()
双向队列队首进队: appendleft()
双向队列队尾出队: pop()
from collections import deque
q = deque([1,2,3,4,5], 5) # 1,2,3进队, 5为最大长度, 可以用来做类似Linux中的tail命令
q.append(1) # 队尾
print(q.popleft()) # 队首 出队
# 用于双向队列
q.appendleft(1) #队首 进队
q.pop() # 队尾出队
栈和队列的应用–迷宫问题
给一个二维列表，表示迷宫(0表示通道,1表示围墙)。 给出算法，求一条走出迷宫的路径。
栈–深度优先搜索
回溯法
思路:从一个节点开始，任意找下一-个
能走的点，当找不到能走的点时，退回
上一个点寻找是否有其他方向的点。
使用栈存储当前路径
maze = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
]
dirs = [
lambda x, y: (x+1, y),
lambda x, y: (x-1, y),
lambda x, y: (x, y-1),
lambda x, y: (x, y+1)
]
def maze_path(x1, y1, x2, y2):
stack = []
stack.append((x1, y1))
while len(stack) > 0:
curNode = stack[-1] # 当前的节点
if curNode[0] == x2 and curNode[1] == y2:
# 走到终点
for p in stack:
print(p)
return True
# x,y 四个方向 x-1,y; x+1,y; x,y-1; x,y+1;
for dir in dirs:
nextNode = dir(curNode[0], curNode[1])
# 如果下一个节点能走
if maze[nextNode[0]][nextNode[1]] == 0:
stack.append(nextNode)
maze[nextNode[0]][nextNode[1]] = 2 # 2表示已经走过
break
else:
maze[nextNode[0]][nextNode[1]] = 2
stack.pop()
else:
print("没有路")
return False
maze_path(1, 1, 8, 8)
队列 – 广度优先搜索
思路:从一个节点开始，寻找所有接
下来能继续走的点，继续不断寻找，
直到找到出口。
使用队列存储当前正在考虑的节点
from collections import deque
maze = [
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1],
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],
[1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
[1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
[1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
[1, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
]
dirs = [
lambda x, y: (x+1, y),
lambda x, y: (x-1, y),
lambda x, y: (x, y-1),
lambda x, y: (x, y+1)
]
def print_r(path):
curNode = path[-1]
realpath = []
while curNode[2] != -1:
realpath.append(curNode[0:2])
curNode = path[curNode[2]]
realpath.append(curNode[0:2])
realpath.reverse()
for node in realpath:
print(node)
def maze_path_queue(x1, y1, x2, y2):
queue = deque()
queue.append((x1, y1, -1))
path = []
while len(queue) > 0:
curNode = queue.popleft()
path.append(curNode)
if curNode[0] == x2 and curNode[1] == y2:
print_r(path)
for dir in dirs:
nextNode = dir(curNode[0], curNode[1])
if maze[nextNode[0]][nextNode[1]] == 0:
queue.append((nextNode[0], nextNode[1], len(path) - 1))
maze[nextNode[0]][nextNode[1]] = 2
else:
print("没有路")
return False
maze_path_queue(1, 1, 8, 8)