Python数据结构与算法——数据结构(栈、队列)

已于 2024-03-31 11:28:06 修改
阅读量938 收藏 17
点赞数 38
分类专栏： python数据结构与算法 文章标签： python 算法 数据结构
于 2024-03-29 22:31:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63043783/article/details/137140350
版权

目录

数据结构介绍

列表

栈

栈的基本操作：

栈的实现（使用一般列表结构即可实现）：

栈的应用——括号匹配问题

队列

队列的实现方式——环形队列

 队列的实现方式——双向队列

 队列内置模块

栈和队列应用——迷宫问题

栈——深度优先搜索

 队列——广度优先搜索

数据结构介绍

介绍：

  • 数据结构是值相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。
  • 简单说：数据结构就是设计数据以何种方式组织并存储在计算机中。
  • 比如：列表、集合与字典等都是一种数据结构。
  • 程序 = 数据结构 + 算法

分类：

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

列表

        列表与其他编程语言的数组有区别：1、数组元素类型相同；2、数组长度固定。

列表：是一种基本数据类型。

操作：

  • 查找：O(1)
  • 插入：O(n)
  • 删除：O(n)

栈

  • 栈：是一个数据集合，可以理解为只能在一端进行插入或者删除操作的列表。
  • 特点：后进先出LIFO
  • 概念：栈顶、栈底

栈的基本操作：

  • 进栈（压栈）：push
  • 出栈：pop
  • 取栈顶：gettop

栈的实现（使用一般列表结构即可实现）：

  • 进栈：li.append
  • 出栈：li.pop
  • 取栈顶：li[-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]
        else:
            return None


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

栈的应用——括号匹配问题

        给一个字符串，其中包含小括号、中括号、大括号，求该字符串中的括号是否匹配。

        例如：()()[]{} 匹配、([{()}]) 匹配、[]( 不匹配、[(]) 不匹配

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(self):
        return len(self.stack) == 0


def brace_match(s):
    stack = Stack()
    match = {'}':'{', ']':'[', ')':'('}
    for ch in s:
        if ch in {'(', '[', '{'}:
            stack.push(ch)
        else:
            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(brace_match("{(){}}{{}{}}"))

队列

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

队列的实现方式——环形队列

环形队列：当队尾指针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.size = 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(6)
for i in range(5):
    q.push(i)
print(q.is_filled())
print(q.pop())
q.push(4)

 队列的实现方式——双向队列

双向队列：两端都支持进队和出队操作

双向队列基本操作：

  •         队首进队
  •         队首出队
  •         队尾进队
  •         队尾出队

 队列内置模块

使用方法：from collections impport deque

        创建队列：queue = deque()

        进队：append()

        出队：popleft()

        双向队列队首进队：appendleft()

        双向队列队尾出队：pop()

# 双向队列
from collections import deque

# 创建队列
q = deque([1, 2, 3, 4, 5], 5)  # 里面的第一个参数为列表，为队列初始化；第二个参数为int，是队列的长度
# 当队列满了之后继续入队，队首位置会向后一位，

q.append(1)  # 队尾入队
q.popleft()  # 队首出队

# 用于双向队列
q.appendleft()  # 队首入队
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, 1, 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):  # (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-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，2表示路以及走过
                break  # 找到一个就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, 1, 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.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)

代码自己手动敲一遍理解更深哦！

依彡
关注
  • 38
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
数据结构与算法 Python语言描述-裘宗燕 高清带目录 详细讲述线性表 、字符串、栈和队列、二叉树和树、图、字典和集合、排序等
基于python数据结构与算法（二）——队列
12-21
一. 抽象数据类型Queue： 队列的尾：rear，首：front（FIFO） 原创文章 26获赞 3访问量 510 关注 私信 展开阅读全文 作者：qq_25871537
Python实现数据结构与算法——设计循环队列
Mantana的博客
02-27 1507
题目描述： 设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 你的实现应该支持如下操作： MyC...
Python实现数据结构与算法——队列的最大值
Mantana的博客
03-09 1512
题目描述： 请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。 若队列为空，pop_front 和 max_value 需要返回 -1 示例1： 输入: ["MaxQueue","push_back","push_back","max_value","pop_front","ma...
Python数据结构与算法——线性结构总结
小杨的博客
06-26 665
文章目录线性结构总结栈 Stack队列 queue双端队列 dequeue链表 线性结构总结 栈、队列、双端队列、链表以及其应用 文章收录于公众号：<小杨的python之路> Github：Python数据结构与算法 栈 Stack 栈stack维持了数据项后进先出LIFO的次序 书写表达式的方法有前缀prefix，中缀infix，后缀postfix，由于栈具有次序反转的特性，所以栈结构适合用于开发表达式求值和转换算法 数据结构之线性结构——栈（Stack Python数据结构与
Python数据结构与算法（3.1）——栈
热门推荐
盼小辉丶的博客
03-07 1万+
栈和队列是在程序设计中常见的数据类型，从数据结构的角度来讲，栈和队列也是线性表，是操作受限的线性表，它们的基本操作是线性表操作的子集，但从数据类型的角度来讲，它们与线性表又有着巨大的不同。本节将首先介绍栈的定义和其不同实现，并且给出栈的一些实际应用。
数据结构与算法Python版——第四周作业
12-21
1有序队列（10分） 题目内容： 一开始给出了一个由小写字母组成的字符串 S。我们规定每次移动中，选择最左侧的字母，将其从原位置移除，并加到字符串的末尾。这样的移动可以执行任意多次 返回我们移动之后可以拥有的...
python数据结构与算法详解与源码
08-20
数据结构与算法（Python） 一、引入概念 1-01算法引入 1-02 时间复杂度与大O表示法 1-03-最坏时间复杂度与计算规则 1-04-常见时间复杂度与大小关系 1-05-代码执行时间测量模块 1-06-Python列表类型不同操作的...
【编译程序介绍】
武帝为此的博客
04-22 1222
简单来说，编译程序是一个软件，它读取用某种编程语言编写的源代码，分析并转换成等效的、可执行的机器语言代码。这个过程涉及多个复杂的步骤，包括语法分析、语义分析、代码优化和代码生成等。
[python3] 读取一个正在更新的日志文件
言之。
04-24 243
等同于–follow=name --retry，根据文件名进行追踪，并保持重试，即该文件被删除或改名后，如果再次创建相同的文件名，会继续追踪。这两种方法都会持续监听日志文件的变化，并实时读取新增的日志内容。你可以根据实际需求选择其中一种方法。要读取一个正在更新的日志文件（即实时写入的日志文件），你可以使用 Python 的。的技巧来实现实时读取。函数打开文件，并使用。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 556
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 621
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
【InternLM实战营---第五节课作业】
weixin_45609124的博客
04-22 804
LMDeploy环境配置及基础使用
Pandas 2.2 中文官方教程和指南（十五）
龙哥盟
04-24 704
原文：pandas.pydata.org/docs/ 处理文本数据 原文：pandas.pydata.org/docs/user_guide/text.html 文本数据类型 在 pandas 中有两种存储文本数据的方式： object -dtype NumPy 数组。 StringDtype 扩展类型。 我们建议使用StringDtype来存储文本数据。 在 pandas 1.0 之前，object dtype 是唯一的选项。这在很多方面都是不幸的： 你可能会在object dty
[SWPUCTF 2021 新生赛]re2（不同字符加密相同，逆向修改范围）
2301_79326813的博客
04-23 161
无壳直接看ida。
Python 二叉树的创建与遍历
youyouxiong的博客
04-24 342
在Python中创建二叉树并进行遍历，我们首先需要定义一个二叉树节点类，然后创建二叉树，最后实现几种基本的遍历方法：前序、中序、后序和层序遍历。以下是具体的实现步骤： 2. 创建二叉树 创建二叉树通常是由用户根据需要输入节点值来构建，或者通过特定的算法生成。这里我们手动创建一个简单的二叉树： 3. 实现二叉树的遍历 前序遍历 (Preorder Traversal) 访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。 中序遍历 (Inorder Traversal) 递归地遍历左子
Semibin2 GTDB 路径手动配置
Dylan's Blog
04-23 185
在 main.py 里的这部分代码的default 替换成你自己的 gtdb 的路径即可，当然，你也可以用参数输入对应的路径。将解压后的文件放到一个文件夹里，default 里填写这个文件夹的绝对路径。
PySide6 GUI 学习笔记——使用资源文件
最新发布
Humbunklung的专栏
04-27 295
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
python数据结构与算法优先队列
11-25
Python中的优先队列可以通过heapq模块来实现。heapq模块提供了堆队列算法，也就是优先队列算法。堆是一种二叉树，它的每个父节点的值都小于或等于其所有子节点的值。因此，堆中最小的元素总是在根节点上，这就是所谓...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值