栈、队列以及迷宫搜索问题

# 数据结构
# 逻辑结构：线性结构（一对一）、树结构（一对多）、图结构（多对多）
# 物理结构：
# 列表：(其他语言称数组)，是一种基本数据类型
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('........................................')