# 数据结构
# 逻辑结构:线性结构(一对一)、树结构(一对多)、图结构(多对多)
# 物理结构:
# 列表:(其他语言称数组),是一种基本数据类型
import random
'''
32位的机器上,一个整数占4字节 a[2] 地址位为100+2*4=108
一个地址也占4个字节
列表中的元素是怎么存储的
基本操作: 按下标查找, 插入元素、 删除元素
时间复杂度: O(1) O(n) o(n)
python的列表的实现
数组和列表的区别::
数组元素类型要相同
数组长度要固定(内存分配)
'''
'''
栈:一个数据集合,只能在一段进行插入或者删除操作
后进后出LIFO
栈 :top bottom
基本操作:
进栈(压栈) :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_pop(self):
if len(self.stack) > 0:
return self.stack[-1]
else:
return None
def is_empty(self):
return len(self.stack) == 0
# stack = Stack()
# stack.push(1)
# 栈的运用
# 括号匹配问题
# 给一个字符串,括号是否匹配
# ([]{}())
def brace_match(s):
match = {'}': '{', ']': '[', ')': '('}
stack = Stack()
for ch in s:
if ch in {'{', '(', '['}:
stack.push(ch)
else: # ch in {'}',')',']'}
if stack.is_empty():
return False
elif stack.get_pop() == match[ch]:
stack.pop()
else: # stack.get_top() !=match[ch]
return False
if stack.is_empty():
return True
else:
return False
print(brace_match('[]{(){{[]}()}}'))
print(brace_match('[{]}'))
'''
队列:仅允许在列表的一端进行插入,另一端进行删除
进行插入的一端为队尾
进行删除的一端为队首
先进先出(FIFO)
front == rear 空队列
简单的使用列表会造成内存的浪费
实现方式可以使用环形队列
队满 front==(rear+1)%Maxsize
空队列 front==rear
出队 front++
入队 rear++
队首指针前进1:front = (front+1)%Maxsize
队尾指针前进1:rear = (rear +1)%Maxsize
'''
class Queue:
def __init__(self, size=100):
self.size = size
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())
print(q.pop())
q.push(2)
print(q.pop())
print('-------------------------------')
# 双向队列:两端都支持进队和出队
import queue
# 保证线程安全的
from collections import deque
# 单向队列
q = deque([1, 2, 3], 5) # 参数: 列表 最大长度:堆满自动出队 ---》Linux的tail命令
q.append(1) # 队尾进队
print(q.popleft()) # 队首出队
# 用于双向队列
q.appendleft(1) # 队首进队
q.pop() # 队尾出队
print("------------------>")
from collections import deque
# 打印后几行
def tail(n):
with open('test.txt', 'r') as f:
q = deque(f, n)
return q
for line in tail(5):
print(line, end='')
# 迷宫搜索问题
'''
给一个二维列表,表示迷宫(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]
]
# 四个方向
# x,y 四个方向
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
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
break
else:
maze[nextNode[0]][nextNode[1]] = 2
stack.pop()
else:
print("没有路!!!")
return False
# maze_path(1, 1, 8, 8)
print('---------------->>>>>>>')
'''
队列---广度优先搜索
从一个节点开始,寻找所有接下来能继续走的点,继续不断寻找,直到找到出口
使用队列存储当前正在考虑的节点
同时走多条路(分支)
回退,找根
需要一个额外的列表记录入队的顺序
'''
from collections import deque
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.pop() # 第一个节点
path.append(curNode)
if curNode[0] == x2 and curNode[1] == y2:
# 终点
print_r(path)
return True
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)
print('........................................')
栈、队列以及迷宫搜索问题
最新推荐文章于 2022-05-28 17:48:07 发布