实验四：栈、队列和树

已于 2024-06-02 22:43:08 修改
阅读量1.8k 收藏 32
点赞数 26
文章标签： python
于 2024-05-31 00:02:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73918454/article/details/139245398
版权

2024年重庆大学大二通信工程课程《数据结构与算法》Data Structure and Algorithms 实验作业记录。（错误在所难免，请多斧正！🤝）

目录

前言

 1. 教材  

课程选用教材，讲解详实全面。

数据结构与算法：Python语言描述（第2版）——裘宗燕--机械工业出版社 (cmpedu.com)icon-default.png?t=N7T8http://www.cmpedu.com/books/book/5605157.htm

上手难度低，易读性强。 

Hello 算法 (roadup.cc)icon-default.png?t=N7T8https://algo.roadup.cc/

 两本教材可以相互结合着看。

2. 环境

PyCharm：用于数据科学和 Web 开发的 Python IDE (jetbrains.com.cn)icon-default.png?t=N7T8https://www.jetbrains.com.cn/en-us/pycharm/

一、实验目的

  1. 理解并掌握栈（Stack）的原理及Python实现；
  2. 理解并掌握队列（Queue）算法及Python实现；
  3. 理解并掌握堆（Heap）的概念。

【栈】或称为堆栈，是一种遵循先入后出（LIFO，Last In First Out）逻辑的线性数据结构。（stack 原意是指一个干草堆；或者泛指一堆、一排或一列整齐堆放的物品。）

【队列】或称为队，是一种遵循先入先出（FIFO，First In First Out）规则的线性数据结构。顾名思义，队列模拟了排队现象。

【堆】用于实现优先队列的完全二叉树（Complete Binary Tree）。从使用角度来看， 可以将“优先队列”和“堆”看作等价的数据结构。分大顶堆和小顶堆，大顶堆相当于元素按从大到小的顺序出队的优先队列。

二、实验内容

2.1 使用顺序表方法和单链表方法实现Stack

【顺序表 Sequential List 】用于存储一系列具有顺序关系的元素，是一种基本的数据结构。Python中的列表（List）就是一种顺序表。

列表是可变的，可以包含任意类型的元素，并且可以根据需要动态添加、删除和修改元素。通过索引可以访问和操作列表中的元素，索引从0开始，依次递增。

顺序表的特点是元素的顺序固定，可以通过索引快速定位元素，并且支持在任意位置进行插入、删除和修改操作。

代码及结果

2.1.1 顺序表实现栈
class SStack:
    def __init__(self):
        self._stack = []

    # 入栈
    def push(self, item: int):
        self._stack.append(item)

    # 判断栈是否为空
    def is_empty(self) -> bool:
        return self._stack == []

    # 出栈
    def pop(self) -> int:
        if self.is_empty():
            raise IndexError('栈为空')
        return self._stack.pop()

    # 访问栈顶元素
    def peek(self) -> int:
        if self.is_empty():
            raise IndexError('栈为空')
        return self._stack[-1]

    # 获取栈的长度
    def size(self):
        return len(self._stack)

    # 返回列表
    def to_list(self):
        return self._stack


st = SStack()
for i in range(1,4):
    st.push(i)
print(f'stack: {st.to_list()}')
print(f'peek: {st.peek()}')
print(f'pop: {st.pop()}')
print(f'stack: {st.to_list()}')

运行结果

stack: [1, 2, 3]
peek: 3
pop: 3
stack: [1, 2]

Process finished with exit code 0

2.1.2  单链表实现栈
class ListNode:
    def __init__(self, val: int):
        self.val: int = val
        self.next: None | ListNode = None


# 单链表实现栈
class LinkedListStack:
    # 构造方法
    def __init__(self):
        self.__peek = None  #栈顶（头节点）
        self.__size = 0

    # 获取栈的长度
    def size(self):
        return self.__size

    # 判断栈是否为空
    def is_empty(self):
        return not self.__peek

    # 入栈
    def push(self, val):
        node = ListNode(val)
        node.next = self.__peek
        self.__peek = node
        self.__size += 1

    # 出栈
    def pop(self):
        num = self.peek()
        self.__peek = self.__peek.next
        self.__size -= 1
        return num

    # 访问栈顶元素
    def peek(self):
        if not self.__peek:
            return None
        return self.__peek.val

    # 返回列表用于打印
    def to_list(self):
        arr = []
        node = self.__peek
        while node:
            arr.append(node.val)
            node = node.next
        arr = arr[::-1]  # 等效于 arr.reverse() （该式子不返回任何值）
        return arr


stack = LinkedListStack()
for i in range(4):
    stack.push(i)

print(f'stack: {stack.to_list()}')
print(f'peek: {stack.peek()}')
print(f'pop: {stack.pop()}')
print(f'stack: {stack.to_list()}')

运行结果 

stack: [0, 1, 2, 3]
peek: 3
pop: 3
stack: [0, 1, 2]

Process finished with exit code 0

2.2 列表(List)实现优先队列

【优先队列 Priority Queue】一种特殊的队列数据结构，其中每个元素都被赋予优先级。

元素按照优先级的高低顺序进行排序，具有最高优先级的元素可以最先被访问或删除。优先队列常常用于解决具有优先级的问题，例如任务调度、数据压缩等。

代码实现

# 基于列表实现优先队列( 1 为优先级最高）
class PriorityQueue:
    def __init__(self):
        self.queue = []

        # 判断是否为空

    def is_empty(self):
        return len(self.queue) == 0

    # 插入
    def insert(self, priority, item):
        for i in range(len(self.queue)):
            if self.queue[i][0] > priority:
                self.queue.insert(i, (priority, item))
                print(f'insert: ({priority}, {item})')
                return   # 不能用break
        # 队列为空时
        self.queue.append((priority, item))
        print(f'insert: ({priority}, {item})')

    # 弹出
    def pop(self):
        if self.is_empty():
            raise Exception('pop from a empty priority queue')
        return self.queue.pop(0)[1]

    # 查看
    def peek(self):
        if self.is_empty():
            raise Exception('peek from a empty priority queue')
        return self.queue[0][1]

    # 队列元素数量
    def size(self):
        return len(self.queue)

    def to_list(self):
        return self.queue


pq = PriorityQueue()
pq.insert(3, 'c')
pq.insert(1, 'a')
print(f'Queue: {pq.to_list()}')
print(f'size: {pq.size()}')
print(f'peek: {pq.peek()}')
print(f'pop: {pq.pop()}')
print(f'queue: {pq.to_list()}')
pq.insert(2, 'b')
print(f'queue: {pq.to_list()}')

结果显示

insert: (3, c)
insert: (1, a)
Queue: [(1, 'a'), (3, 'c')]
size: 2
peek: a
pop: a
queue: [(3, 'c')]
insert: (2, b)
queue: [(2, 'b'), (3, 'c')]

Process finished with exit code 0

2.3 堆实现优先队列

在实际应用中，我们可以直接使用编程语言提供的堆类（或优先队列类）“ heapq ”。

代码实现

# 直接使用Python的heapq模块实现
import heapq

# heapq模块默认实现小顶堆
min_heap = []
heapq.heappush(min_heap, (1, 'a'))
heapq.heappush(min_heap, (2, 'b'))
heapq.heappush(min_heap, (3, 'c'))
print(f'min_heap: {min_heap}')
print(f'peek: {min_heap[0]}\n')

min_heap1 = [3, 9, 7, 4, 6]
heapq.heapify(min_heap1)
print(f'min_heap1: {min_heap1}')
print('pops: ',end='')
while min_heap1:
    print(f'{heapq.heappop(min_heap1)}', end=' ')

 用heapq时候为什么元组和整数都可以入堆？

在Python中，heapq 模块实现的是基于比较的堆，它要求堆中的元素是可比较的。故不论是整数、浮点数、字符串，还是自定义的对象或元组，都可以作为堆的元素。

对于元组，Python中元组的比较是基于元素逐个比较的，从左到右。如果两个元组在相应位置的元素相等，则比较下一个元素，直到找到不相等的元素为止，或者比较完所有元素。

结果显示

min_heap: [(1, 'a'), (2, 'b'), (3, 'c')]
peek: (1, 'a')

min_heap1: [3, 4, 7, 9, 6]
pops: 3 4 6 7 9 
Process finished with exit code 0

2.4 实现二叉堆

【二叉堆 Binary Heap】

二叉堆是一种基于完全二叉树的数据结构，它满足以下性质：

  1. 它是一个完全二叉树，意味着除了最后一层，其他层的节点都是满的，并且最后一层的节点尽量靠左排列。
  2. 每个节点的值都大于或等于其子节点的值（对于最大堆 max heap），或者每个节点的值都小于或等于其子节点的值（对于最小堆 min heap）。

二叉堆通常使用数组来表示，其中根节点存储在索引 0 处，而其他节点的位置可以通过一些算法来计算。这使得插入和删除操作的时间复杂度为 O(log n)，其中 n 是堆中元素的数量。

除了常见的插入和删除操作，二叉堆还常用于实现优先级队列。在优先级队列中，每个元素都有一个关联的优先级，高优先级的元素先出队列。二叉堆的性质使得其能够高效地找到和删除具有最高（或最低）优先级的元素。

代码实现

# 用数组表示堆来实现优先队列
def left(i: int) -> int:
    return i * 2 + 1


def right(i: int) -> int:
    return i * 2 + 2


def parent(i: int) -> int:
    return (i - 1) // 2  # //为向下整除


class my_heap:
    def __init__(self):
        self.min_heap = []

    def size(self):
        return len(self.min_heap)

    # 访问堆顶
    def peek(self):
        if not self.min_heap:
            raise IndexError('堆为空')
        return self.min_heap[0]

    def swap(self, i: int, p: int):
        temp = self.min_heap[i]
        self.min_heap[i] = self.min_heap[p]
        self.min_heap[p] = temp

    # 堆化 （上移）
    def sift_up(self, i: int):
        while i != 0:
            if self.min_heap[i] < self.min_heap[parent(i)]:
                self.swap(i, parent(i))
                i = parent(i)
            else:
                break

    # 入堆
    def push(self, val: int):
        self.min_heap.append(val)
        self.sift_up(len(self.min_heap) - 1)

    # 判断是否为空
    def is_empty(self):
        return not self.min_heap

    # 出堆
    def pop(self):
        if self.is_empty():
            raise IndexError('Empty Heap')
        else:
            self.swap(0, -1)
            val = self.min_heap.pop()
            self.sift_down(0)
            return val

    # 下移
    def sift_down(self, i: int):
        while True:
            # 判断节点i,l,r中值最小的节点,记为mi（min在python是一个函数）
            l, r, mi = left(i), right(i), i
            if l < self.size() and self.min_heap[mi] > self.min_heap[l]:
                mi = l
            if r < self.size() and self.min_heap[mi] > self.min_heap[r]:
                mi = r
            # 跳出循环：i已经是最小节点，或者l,r越界
            if i == mi:
                break
            # 交换节点
            self.swap(mi, i)
            # 继续堆化
            i = mi

    # 转成列表输出
    def to_list(self):
        return self.min_heap


heap = my_heap()
print('push: ',end='')
arr = [4,3,5,6,1,7,2]
for i in arr:
    heap.push(i)
    print(f'{i}',end=' ')
print(f'\npeek: {heap.peek()}')
print(f'heap: {heap.to_list()}')
print()
for _ in range(heap.size()):
    print(f'pop: {heap.pop()}')
    print(f'heap: {heap.to_list()};')

sift : sift 被借用来描述数据结构（尤其是堆）中的元素移动操作，如 "sift up" 和 "sift down"，用来维护堆的有序性。原意为“筛分”、“过滤”，如筛面粉。

结果显示

push: 4 3 5 6 1 7 2 
peek: 1
heap: [1, 3, 2, 6, 4, 7, 5]

pop: 1
heap: [2, 3, 5, 6, 4, 7];
pop: 2
heap: [3, 4, 5, 6, 7];
pop: 3
heap: [4, 6, 5, 7];
pop: 4
heap: [5, 6, 7];
pop: 5
heap: [6, 7];
pop: 6
heap: [7];
pop: 7
heap: [];

Process finished with exit code 0

总结

上实验课前要复习相关知识。

AI的强大：在写代码的过程中，遇到困难（知识点忘记，调试不过）是肯定的。以前是翻书，现在就是直接问AI。

实验课后及时整理报告。发成博客是很好的选择，很能激励自己尽快完成。

Qiming_Peng
关注
  • 26
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【数据结构与算法】实验三 栈和队列
兔子王
10-08 1580
【实验内容】1. 编写程序实现顺序栈的相关操作。2. 编写程序实现循环队列的相关操作。3. 实现栈的应用——数制转换（十进制转换为二进制）。4. 实现栈的应用——判断表达式括号是否匹配。5. 栈和递归。6. 设计程序实现简单的四则运算。
python每日算法 | 数据结构基础：栈与队列以及经典的迷宫问题
REPCHAOCHAO的博客
09-12 1245
python每日算法：数据结构基础知识（一）：栈与队列以及最经典的迷宫问题
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 1910
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
数据结构实验三——栈和队列的基本操作
weiyuexin的博客
10-11 5762
** 一、实验内容 ** 1. 实验目的 编程实现顺序栈和链栈的基本操作：建栈，取栈顶元素，入栈，出栈； 编程实现循环队列和链队列的基本操作：建队列，取队头元素，入队，出队。 2. 基本要求 掌握栈的顺序存储结构、链式存储结构及其基本操作； 掌握队列的顺序存储结构、链式存储结构及其基本操作。 4. 支撑的课程目标 本实验项目可以支撑“目标1. 理解数据结构的基本概念、计算机内部数据对象的表示和特性。掌握线性表、树、图等数据逻辑结构、存储结构及其差异以及各种操作的实现。”、和“目标2能够针对实际问题选
数据结构实验--栈和队列与二叉树
m0_72747430的博客
02-26 462
数据结构
「leetcode」栈与队列：总结篇！
代码随想录
09-23 493
算上本篇，栈与队列我们已经讲了九篇文章了，总结篇如约而至！
Java简单实现栈和队列（附代码和理论知识）
qq_40346958的博客
09-22 489
文章目录1、栈2、队列 数据结构之栈和队列 数组和链表是线性表的物理存储结构：即顺序存储和链式存储，栈和队列都属于线性表的逻辑存储结构。 上面这句话啥意思？ 我们知道常见的数据结构中有一个线性表，线性表包括：数组、链表、栈、队列。 物理存储结构：数据在物理存储空间上选择集中存放还是分散存放，如数组（顺序存储结构）、链表（链式存储结构）。 逻辑存储结构：数据之间的逻辑关系，需要借助物理存储结构进行设计以体现出数据之间的逻辑关系。如：栈、队列、树、图。 上面的那些不利于理解的话我们可以简单理解为：物理存
数据结构：队列与栈问题
Kobe51920的博客
11-03 1307
1.队列与栈（栈有记忆功能，队列删除,插入效率比较低下） 1. 队列删除元素是在队首进行，队列是现进现出，相对来说，队首元素是最先进入队列的，因此出队应该是在队首进行。队列其实就和我们平时排队一样的 2. 栈与队列是非线性结构，应该是线性结构，再确切点说是访问受限的线性表 线性链表是非线性结构，应该是线性结构 二叉树是线性结构，应该是非线性结构（层次结构 3. BFS需要...
C++数据结构实验二：树和二叉树
m0_73700621的博客
06-14 1067
C++数据结构实验：树和二叉树。建立二叉树的二叉链表；实现二叉树的中序递归遍历算法、前缀和后缀遍历算法；实现二叉树的中序非递归遍历算；借助队列实现二叉树的层次遍历算法；求二叉树的高度；求二叉树的结点个数；求二叉树的叶子个数；交换二叉树每个结点的左子树和右子树
数据结构5个实验+实验1线性表+实验2栈与队列+实验3树和二叉树+实验4图+实验5查找与排序
04-17
这个压缩包包含五个重要的实验，涵盖了数据结构的基础和关键概念，包括线性表、栈与队列、树和二叉树、图以及查找与排序。 实验1：线性表 线性表是最基础的数据结构之一，它是一组按顺序排列的元素集合。在这个实验...
C++数据结构实验_实现共享栈，链栈，循环队列，链队列
12-07
在这个实验中，我们将关注四种特定的数据结构：共享栈、链栈、循环队列和链队列。这些数据结构在各种算法和应用程序中都有广泛应用。 首先，我们来看共享栈（Shared Stack）。共享栈是一种特殊的栈，其中多个线程...
数据结构栈和队列实验报告.doc
10-11
"数据结构栈和队列实验报告" 本实验报告的主要目的是为了理解栈和队列的特征，以及它们之间的差异，在何时使用那种数据结构。同时，掌握在顺序栈和链栈上实现栈的基本运算算法，并且了解栈满和栈空的条件。另外，...
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
06-09
本实验报告涵盖了数据结构课程的十个实验项目，详细介绍了线性表、栈和队列、串、二叉树、图、查找和排序算法的设计与实现。每个实验项目包括多个子项目，从基础的顺序表、单链表、双链表、循环链表等基本运算，到...
实验四：图的遍历1
08-08
实验四：“图的遍历1”旨在让学生理解图的主要存储结构，掌握图的构建算法以及图的深度优先遍历（DFS）和广度优先遍历（BFS）算法。实验内容涉及图的邻接表和邻接矩阵存储，以及拓扑排序和最小生成树问题的解决方案...
cv2读取和保存图片
最新发布
m0_53291740的博客
07-12 121
cv2.imwrite('b\\img1.png',img)#b存在就可以保存进去。如果b存在，c不存在，程序不会报错，也不会保存图片。如果目录b不存在就会存到当前文件夹。
面试题 21：解释 Python 中的 help() 函数和 dir() 函数？
专注于全栈开发领域
07-10 753
在Python中，help()和dir()是两个非常有用的内置函数，它们可以帮助开发者更好地了解Python对象和模块。
Nginx七层（应用层）反向代理：UWSGI代理uwsgi_pass篇
jclee95的个人博客
07-10 1055
Nginx提供了多种应用层反向代理支持，包括proxy_pass、uwsgi_pass、fastcgi_pass和scgi_pass等。其中，proxy_pass指令可以接受一个URL参数，用于实现对HTTP/HTTPS协议的反向代理；uwsgi_pass用于代理到uWSGI应用服务器；fastcgi_pass用于代理到FastCGI服务器；而scgi_pass则用于代理到SCGI（Simple Common Gateway Interface）应用。这些指令使Nginx能够灵活地处理不同类型的后端服务和应
聊聊如何在内网下构建大模型微调环境
python1234567_的博客
07-12 694
LlamaFactory新版更新后，还是比较方便，只是说llamafactory-cli命令的确是有点蒙，踩个坑就好了。对于LlamaFactory微调来说，本身不难，毕竟都是配置；主要是在内网环境下的依赖包拉取安装是真麻烦，但其实也还好。走一遍的话，还是可以学到很多的。​。
北邮数据结构实验报告.doc
12-16
实验名称：实验三——栈和队列 学生姓名： 班级： 班内序号： 学号： 日期： 1. 实验要求 1.1 实验目的 本次实验的主要目的是通过选择下面两个题目之一进行实现，以掌握以下内容： - 根据二叉树的抽象数据类型的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Qiming_Peng

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值