【数据结构1】数据结构的分类、数组和列表的区别、栈(括号匹配问题)、队列(双向对列、环形队列、队列内置模块)、从队列读取文件、栈和队列的应用(迷宫问题-[栈-深度优先搜索]、[队列-广度优先搜索])

林光虚霁晓

已于 2024-08-23 22:24:48 修改

阅读量338

点赞数 5

分类专栏：算法题文章标签：数据结构分类数据挖掘

于 2024-08-23 20:52:52 首次发布

本文链接：https://blog.csdn.net/weixin_44145338/article/details/141471102

版权

算法题专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1 数据结构的分类
 2 数组和列表的区别
 3 栈
 3.1 栈的基本实现
 3.2 栈的应用：括号匹配问题
 4 队列
 4.1 环形队列的实现
 4.2 双向对列
 4.3 python队列内置模块
 4.4 从队列读取文件
 5 栈和队列的应用：迷宫问题
 6 栈和队列的应用(迷宫问题[队列-广度优先搜索])

1 数据结构的分类

数据结构按照其逻辑结构可分为线性结构、树结构、图结构
线性结构:数据结构中的元素存在一对一的相互关系
树结构:数据结构中的元素存在一对多的相互关系
图结构:数据结构中的元素存在多对多的相互关系

2 数组和列表的区别

数组与列表有两点不同:
	1.数组元素类型要相同
	2.数组长度固定

3 栈

栈(Stack)是一个数据集合，可以理解为只能在一端进行插入或删除操作的列表。
栈的特点:后进先出 LIFO(last-in,frst-out)
栈的概念:栈顶、栈底

-栈的基本操作:
	进栈(压栈):push
	出栈:pop
	取栈顶:gettop

-栈的实现：使用一般的列表结构即可实现栈
	进栈:li.append
	出栈:li.pop
	取栈顶:li[-1]

在这里插入图片描述

3.1 栈的基本实现

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]
        return None


stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop())

3.2 栈的应用：括号匹配问题

def brace_match(s):
    stack = Stack()
    match = {'}': '{', ']': '[', ')': '('}
    for ch in s:
        if ch in {'(', '[', '{'}:
            stack.push(ch)
        else:  # ch in {'}', ']', ')'}
            if stack.is_empty():
                return False
            elif stack.get_top() == match[ch]:
                stack.pop()
            else:  # stack.get_top() != mathc[ch]
                return False
    if stack.is_empty():
        return True
    return False


print(brace_match('[{()}(){()}[]({}){}]'))  # True
print(brace_match('[]}'))  # False

4 队列

队列(Queue)是一个数据集合，仅允许在列表的一端进行插入，另一端进行删除。
进行插入的一端称为队尾(rear)，插入动作称为进队或入队
进行删除的一端称为队头(front)，删除动作称为出队
队列的性质:先进先出(First-in,First-out)

在这里插入图片描述

4.1 环形队列的实现

环形队列:当队尾指针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):
        """
        初始化一个循环队列。
        :param size: 队列的最大容量（默认值为100）
        """
        # 创建一个固定大小的列表来存储队列元素
        self.queue = [0 for _ in range(size)]
        self.size = size  # 队列的最大容量
        self.rear = 0     # 队尾指针，指向下一个插入位置
        self.front = 0    # 队首指针，指向下一个删除位置

    def push(self, element):
        """
        将元素插入队列。
        :param element: 要插入的元素
        :raises IndexError: 如果队列已满，则抛出异常
        """
        if not self.is_filled():  # 检查队列是否已满
            self.queue[self.rear] = element  # 在队尾位置插入元素
            self.rear = (self.rear + 1) % self.size  # 更新队尾指针，使用模运算实现循环
        else:
            raise IndexError('Queue is filled!')  # 如果队列已满，抛出异常

    def pop(self):
        """
        从队列中删除并返回队首元素。
        :return: 从队列中删除的元素
        :raises IndexError: 如果队列为空，则抛出异常
        """
        if not self.is_empty():  # 检查队列是否为空
            element = self.queue[self.front]  # 获取队首元素
            self.front = (self.front + 1) % self.size  # 更新队首指针，使用模运算实现循环
            return element
        else:
            raise IndexError('Queue is empty!')  # 如果队列为空，抛出异常

    def is_empty(self):
        """
        检查队列是否为空。
        :return: 如果队列为空，返回True；否则，返回False
        """
        # 队列为空的条件是队尾指针和队首指针相同
        return self.rear == self.front

    def is_filled(self):
        """
        检查队列是否已满。
        :return: 如果队列已满，返回True；否则，返回False
        """
        # 队列满的条件是队尾指针的下一个位置与队首指针相同
        return (self.rear + 1) % self.size == self.front


q = Queue(5)
for i in range(4):
    q.push(i)
print(q.is_filled())  # True

在这里插入图片描述

4.2 双向对列

双向队列的两端都支持进队和出队操作
双向队列的基本操作:
	队首进队
	队首出队
	队尾进队
	队尾出队

在这里插入图片描述

4.3 python队列内置模块

使用方法:from collections import deque
创建队列:queue = deque()
p进队:append()
出队:popleft()
双向队列队首进队:appendleft()
双向队列队尾出队:pop()

from collections import deque

# 创建一个双向队列（deque）对象 q
# q = deque()

# 使用指定的初始元素和最大长度来创建双向队列
q = deque([1, 2, 3], 5)  # 初始化队列 q，包含元素 1, 2, 3，最大长度为 5

# 操作单向队列

# 队尾进队：将元素 6 添加到队列的末尾
q.append(6)

# 队首出队：移除并返回队列的第一个元素
# q.popleft()
print(q.popleft())  # 输出: 1

# 操作双向队列

# 队首进队：将元素 1 添加到队列的开头
q.appendleft(1)

# 队尾出队：移除并返回队列的最后一个元素
q.pop()

4.4 从队列读取文件

from collections import deque


def tail(n):
    with open('test.txt', 'r') as f:
        q = deque(f, n)
        return q


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

5 栈和队列的应用：迷宫问题

栈：深度优先搜索
回溯法
思路:从一个节点开始，任意找下一个能走的点，当找不到能走的点时，退回上一个点寻找是否有其他方向的点。
使用栈存储当前路径

# 1代表墙  0代表通道
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: int, y1: int, x2: int, y2: int) -> bool:
    """
     在迷宫中寻找从 (x1, y1) 到 (x2, y2) 的路径
    :param x1: 起点的x坐标
    :param y1: 起点的y坐标
    :param x2: 终点的x坐标
    :param y2: 终点的y坐标
    :return: 如果找到路径返回 True，并打印路径；否则返回 False
    """
    stack = []  # 用栈来存储路径
    stack.append((x1, y1))  # 将起点坐标入栈
    while len(stack) > 0:  # 当栈不为空时，循环寻找路径
        cur_node = stack[-1]  # 取当前路径的最后一个节点作为当前节点
        if cur_node[0] == x2 and cur_node[1] == y2:  # 如果当前节点是终点
            for p in stack:  # 打印路径
                print(p)
            return True  # 找到路径，返回 True
        # 尝试从当前节点向四个方向移动
        for dir in dirs:
            next_node = dir(cur_node[0], cur_node[1])  # 计算下一个节点的位置
            # 如果下一个节点是通道（未访问过）
            if maze[next_node[0]][next_node[1]] == 0:
                stack.append(next_node)  # 将下一个节点入栈
                maze[next_node[0]][next_node[1]] = 2  # 标记该节点已访问过
                break  # 成功移动到新节点，退出当前循环
        else:
            maze[next_node[0]][next_node[1]] = 2
            stack.pop()  # 如果四个方向都无法移动
    else:  # 如果栈为空且未找到路径
        print('无路可走')
        return False  # 返回 False，表示没有找到路径


# 调用迷宫路径寻找函数，从 (1, 1) 到 (8, 8)
print(maze_path(1, 1, 8, 8))

6 栈和队列的应用(迷宫问题[队列-广度优先搜索])

思路:从一个节点开始，寻找所有接下来能继续走的点，继续不断寻找，直到找到出口。
使用队列存储当前正在考虑的节点

图形演示
在这里插入图片描述

from collections import deque


# 1代表墙  0代表通道
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_node(path):
    """
    还原并打印从起点到终点的实际路径
    :param path: 保存路径的列表，每个元素是一个三元组，表示当前节点的坐标和其父节点的索引
    """
    real_path = list()  # 存储实际路径
    i = len(path) - 1  # 从路径的最后一个节点开始回溯
    while i >= 0:
        real_path.append(path[i][0:2])  # 将当前节点的坐标添加到实际路径中
        i = path[i][2]  # 继续回溯到父节点
    real_path.reverse()  # 由于是从终点回溯到起点，所以需要反转路径
    for node in real_path:
        print(node)  # 打印实际路径中的每个节点坐标

def maze_path_queue(x1: int, y1: int, x2: int, y2: int) -> bool:
    """
    使用广度优先搜索（BFS）在迷宫中寻找从 (x1, y1) 到 (x2, y2) 的路径
    :param x1: 起点的x坐标
    :param y1: 起点的y坐标
    :param x2: 终点的x坐标
    :param y2: 终点的y坐标
    :return: 如果找到路径返回 True，否则返回 False
    """
    queue = deque()  # 初始化队列用于BFS
    path = list()  # 保存已访问节点的路径，每个元素包含节点坐标和其父节点的索引
    queue.append((x1, y1, -1))  # 将起点节点入队，初始节点没有父节点，因此索引为 -1
    
    while len(queue) > 0:  # 当队列不空时，继续寻找路径
        cur_node = queue.popleft()  # 从队列中取出当前节点
        path.append(cur_node)  # 将当前节点加入到路径中
        if cur_node[0] == x2 and cur_node[1] == y2:  # 检查当前节点是否为终点
            print_node(path)  # 如果到达终点，则打印实际路径
            return True  # 返回 True 表示成功找到路径
        
        # 遍历当前节点的四个可能的移动方向
        for dir in dirs:
            next_node = dir(cur_node[0], cur_node[1])  # 计算下一个节点的坐标
            # 如果下一个节点是通道（未访问过）
            if maze[next_node[0]][next_node[1]] == 0:
                queue.append((next_node[0], next_node[1], len(path) - 1))  # 将下一个节点入队，并记录其父节点的索引
                maze[next_node[0]][next_node[1]] = 2  # 标记该节点已访问过，避免重复访问
    
    else:  # 如果队列为空，且未找到路径
        return False  # 返回 False 表示没有找到路径



# 调用迷宫路径寻找函数，从 (1, 1) 到 (8, 8)
print(maze_path_queue(1, 1, 8, 8))