队列 队列内置函数 用栈解决迷宫问题（深度优先搜索） 用列表解决（广度优先）

class Queue:
	def __init__(self,size=100):
		self.queue = [0 for _ in range(size)]
		self.size = size
		self.rear = 0#队尾指针 进队
		self.front = 0 #队首指针，出队
	def push(self,element):#1 2 3 ->   - 1 2 3]
		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)
for i in range(2):
	print(q.pop())	

在这里插入图片描述

from collections import  deque

# q = deque([1,2,3,4,5],5)
# q.append(6)  #队尾进队
# print(q.popleft()) #队首出队
#用于双向队列
# q.appendleft(1) #队首进队
# q.pop() #队尾出队

def tail(n):
	'''
	with open(r'filename.txt') as f:
		data_user=pd.read_csv(f)  #文件的读操作

	with open('data.txt', 'w') as f:
		f.write('hello world')  #文件的写操作
	'''
	with open('test.txt','r') as f:
		q = deque(f,n)
		return q

for line in tail(5):
	print(line,end = '')

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,1,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]
]

directions = [
	lambda  x,y : (x,y+1),
	lambda  x,y : (x+1,y),
	lambda  x,y : (x,y-1),
	lambda  x,y : (x-1,y)
]
def maze_path(x1,y1,x2,y2):
	stack = []
	stack.append((x1,y1))#stack列表下标存的内容一个（x，y）坐标元组
	while(len(stack)>0):
		curNode = stack[-1]#当前节点,也就是栈顶存的内容
		# print(curNode)
		# break
		#curNode（1,1）
		if curNode[0] == x2 and curNode[1] ==y2:#走到终点
			for p in stack:
				print(p,end='->')
			return True
		#x,y四个方向 (x,y+1);(x+1,y);(x,y-1);(x-1,y)
		for dir in directions:#directions 是个存有四个方向的列表，遍历四个方向
			nextNode = dir(curNode[0],curNode[1])#dir格式参照directions,是个坐标（x,y）
			if maze[nextNode[0]][nextNode[1]] == 0:
				stack.append(nextNode)
				maze[nextNode[0]][nextNode[1]] = 2
				break
		else:
			maze[nextNode[0]][nextNode[1]] = 2
			stack.pop()
	else:
		print('not path there')
		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]
]

directions = [
	lambda  x,y : (x,y+1),
	lambda  x,y : (x+1,y),
	lambda  x,y : (x,y-1),
	lambda  x,y : (x-1,y)
]
def print_r(path):
	curNode = path[-1]
	real_path =[]
	while curNode[2] != -1:
		real_path.append((curNode[0],curNode[1]))#curNode[0:2]
		curNode = path[curNode[2]]
	real_path.append(curNode[0:2])#起点append进去
	real_path.reverse()
	for node in real_path:
		print(node)
def maze_path_queue(x1,y1,x2,y2):
	queue = deque()
	queue.append((x1,y1,-1))#三个参数 x，y，上一个节点
	path = []
	while len(queue) >0:
		curNode = queue.popleft()
		path.append(curNode)
		if curNode[0] == x2 and curNode[1] ==y2:
			print_r(path)
			return True
		for dir in directions:
			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('no path there')
		return  False

maze_path_queue(1,1,8,8)