关于python的内置堆

最新推荐文章于 2023-11-30 08:49:05 发布
最新推荐文章于 2023-11-30 08:49:05 发布
阅读量418 收藏 2
点赞数 1
文章标签： python 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Python_222/article/details/129669803
版权

1.简介

堆，又称优先队列，是一个完全二叉树，它的每个父节点的值都只会小于或等于所有孩子节点（的值）。 它使用了数组来实现：从零开始计数，对于所有的 k ，都有 heap[k] <= heap[2k+1] 和 heap[k] <= heap[2k+2]。 为了便于比较，不存在的元素被认为是无限大。 堆最有趣的特性在于最小的元素总是在根结点：heap[0]。

python的堆一般都是最小堆，与很多教材上的内容有所不同，教材上大多以最大堆，由于堆的表示方法，从上到下，从左到右存储，与列表十分相似，因此创建一个堆，可以使用list来初始化为 [] ，或者你可以通过一个函数 heapify() ，来把一个list转换成堆。如下是python中关于堆的相关操作，从这可以看出，python确实是将堆看作是列表去处理的。
在这里插入图片描述

2.堆的相关操作

heapq.heappush(heap, item)

将 item 的值加入 heap 中，保持堆的不变性。会自动依据python中的最小堆特性，交换相关元素使得堆的根节点元素始终不大于子节点元素。

原有数据是堆
import heapq

h = [1, 2, 3, 5, 7]
heapq.heappush(h, 2)
print(h)
#输出
[1, 2, 2, 5, 7, 3]

操作流程如下:

1.如下是初始状态
在这里插入图片描述

2.添加了2元素之后

在这里插入图片描述
3.由于不符合最小堆的特性，因此与3进行交换
在这里插入图片描述
4.符合最小堆的特性，交换结束，因此结果是[1, 2, 3, 5, 7, 3]

原有数据不是堆
import heapq

h = [5, 2, 1, 4, 7]
heapq.heappush(h, 2)
print(h)
#输出
[5, 2, 1, 4, 7, 2]

由此可见，当进行push操作时，元素不是堆的情况下，默认按照列表的append方法进行添加元素

heapq.heappop(heap)

弹出并返回 heap 的最小的元素，保持堆的不变性。如果堆为空，抛出 IndexError 。使用 heap[0] ，可以只访问最小的元素而不弹出它。

原有数据是堆
import heapq

h = [1, 2, 3, 5, 7]
heapq.heappop(h)
print(h)
#输出
[2, 5, 3, 7]

操作流程如下：

1.初始状态
在这里插入图片描述

2.删除了堆顶元素，末尾元素移入堆顶
在这里插入图片描述

3.依据python最小堆的特性进行交换元素，由于7>2，交换7和2
在这里插入图片描述

4.依据python最小堆的特性进行交换元素，由于7>5，交换7和5
在这里插入图片描述

5.符合堆的要求，即结果为[2, 5, 3, 7]

原有数据不是堆
import heapq

h = [5, 2, 1, 4, 7]
heapq.heappop(h)
print(h)

[1, 2, 7, 4]

操作流程如下：

1.初始状态，很明显不符合堆的性质
在这里插入图片描述

2.移除最上面的元素（第一个元素）,重新对剩下的元素进行堆的排列
在这里插入图片描述

3.依据python最小堆的特性，2>1 交换2与1
在这里插入图片描述

4.符合堆的要求，结果为[1, 2, 7, 4]

heapq.heappushpop(heap, item)

将 item 放入堆中，然后弹出并返回 heap 的最小元素。该组合操作比先调用 heappush() 再调用 heappop() 运行起来更有效率。需要注意的是弹出的元素必须位于堆顶或者堆尾，也就是说当插入一个元素后，进行比较最小元素时，其实一直比较的都是堆顶元素，如果插入元素大于或等于堆顶元素，则堆不会发生变化，当插入元素小于堆顶元素，则堆会依据python堆的最小堆特性进行处理。

原有数据是堆
import heapq

h = [1, 2, 3, 5, 7]
min_data = heapq.heappushpop(h, 2)
print(min_data)
print(h)
#输出
1
[2, 2, 3, 5, 7]

操作流程如下

1.初始状态
在这里插入图片描述
2.插入元素2
在这里插入图片描述

3.删除最小元素，刚好是堆顶元素1，并使用末尾元素2代替
在这里插入图片描述

4.符合要求，即结果为[2, 2, 3, 5, 7]

原有数据不是堆
h = [5, 2, 1, 4, 7]
min_data = heapq.heappushpop(h, 2)
print(min_data)
print(h)
min_data = heapq.heappushpop(h, 6)
print(min_data)
print(h)
#学习中遇到问题没人解答？小编创建了一个Python学习交流群：725638078

#输出
2
[5, 2, 1, 4, 7]
5
[1, 2, 6, 4, 7]

对于插入元素6的操作过程如下

1.初始状态
在这里插入图片描述
2.插入元素6之后
在这里插入图片描述

3.发现元素6大于堆顶元素5，弹出堆顶元素5，由堆尾元素6替换
在这里插入图片描述

4.依据python的最小堆特性，元素6>元素1且元素6>元素2，但元素2>元素1， 交换6与1
在这里插入图片描述

5.符合要求，则结果为[1, 2, 6, 4, 7]
由结果可以看出，当插入元素小于堆顶元素时，则堆不会发生改变，当插入元素大于堆顶元素时，则堆依据python堆的最小堆特性处理。

heapq.heapify(x)

将列表转换为堆。

h = [1, 2, 3, 5, 7]
heapq.heapify(h)
print(h)
h = [5, 2, 1, 4, 7]
heapq.heapify(h)
print(h)
#输出
[1, 2, 3, 5, 7]
[1, 2, 5, 4, 7]

会自动将列表依据python最小堆特性进行重新排列。

heapq.heapreplace(heap, item)

弹出并返回最小的元素，并且添加一个新元素item，这个单步骤操作比heappop()加heappush() 更高效。适用于堆元素数量固定的情况。

返回的值可能会比添加的 item 更大。 如果不希望如此，可考虑改用heappushpop()。 它的 push/pop 组合会返回两个值中较小的一个，将较大的值留在堆中。

import heapq


h = [1, 2, 3, 5, 7]
heapq.heapreplace(h, 6)
print(h)
h = [5, 2, 1, 4, 7]
heapq.heapreplace(h, 6)
print(h)
#输出
[2, 5, 3, 6, 7]
[1, 2, 6, 4, 7]
原有数据是堆

对于插入元素6的操作过程如下：
1.初始状态
在这里插入图片描述

2.弹出最小元素，只能弹出堆顶或者堆尾的元素，很明显，最小元素是1，弹出1，插入元素是6，代替堆顶元素
在这里插入图片描述

3.依据python堆的最小堆特性，6>2,交换6与2
在这里插入图片描述

4.依据python堆的最小堆特性，6>5,交换6与5
在这里插入图片描述

5.符合要求，则结果为[2, 5, 3, 6 ,7]

原有数据不是堆

对于插入元素6的操作过程如下：
1.初始状态
在这里插入图片描述

2.对于数据不为堆的情况下，默认移除第一个元素，这里就是元素5，然后插入元素6到堆顶
在这里插入图片描述

3.依据python的最小堆特性，元素6>1,交换元素6与1
在这里插入图片描述

4.符合要求，即结果为[1, 2, 6, 4, 7

heapq.merge(*iterables, key=None, reverse=False)

将多个已排序的输入合并为一个已排序的输出（例如，合并来自多个日志文件的带时间戳的条目）。 返回已排序值的 iterator。注意需要是已排序完成的可迭代对象（默认为从小到大排序），当reverse为True时，则为从大到小排序。

heapq.nlargest(n, iterable, key=None)

从 iterable 所定义的数据集中返回前 n 个最大元素组成的列表。 如果提供了 key 则其应指定一个单参数的函数，用于从 iterable 的每个元素中提取比较键 (例如 key=str.lower)。

等价于: sorted(iterable, key=key, reverse=True)[:n]。

import time
import heapq

h = [1, 2, 3, 5, 7]

size = 1000000
start = time.time()
print(heapq.nlargest(3, h))
for i in range(size):
    heapq.nlargest(3, h)
print(time.time() - start)

start = time.time()
print(sorted(h, reverse=True)[:3:])
for i in range(size):
    sorted(h, reverse=True)[:3:]
print(time.time() - start)
#输出
[7, 5, 3]
1.6576552391052246
[7, 5, 3]
0.2772986888885498
[7, 5, 4]

由上述结构可见，heapq.nlargest与sorted(iterable, key=key, reverse=False)[:n]功能是类似的，但是性能方面还是sorted较为快速。
heapq.nsmallest(n, iterable, key=None)

从 iterable 所定义的数据集中返回前 n 个最小元素组成的列表。 如果提供了 key 则其应指定一个单参数的函数，用于从 iterable 的每个元素中提取比较键 (例如 key=str.lower)。 等价于: sorted(iterable, key=key)[:n]。

import time
import heapq

h = [1, 2, 3, 5, 7]

size = 1000000
start = time.time()
print(heapq.nsmallest(3, h))
for i in range(size):
    heapq.nsmallest(2, h)
print(time.time() - start)

start = time.time()
print(sorted(h, reverse=False)[:3:])
for i in range(size):
    sorted(h, reverse=False)[:2:]
print(time.time() - start)
#输出
[1, 2, 3]
1.1738648414611816
[1, 2, 3]
0.2871997356414795

由上述结果可见，sorted的性能比后面两个函数都要好，但如果只是返回最大的或者最小的一个元素，则使用max和min最好。

3.堆排序

由于在python中堆的特性是最小堆，堆顶的元素始终是最小的，可以将序列转换成堆之后，再使用pop弹出堆顶元素来实现从小到大排序。具体实现如下：

from heapq import heappush, heappop, heapify


def heapsort(iterable):
    h = []
    for value in iterable:
        heappush(h, value)
    return [heappop(h) for i in range(len(h))]


def heapsort2(iterable):
    heapify(iterable)
    return [heappop(iterable) for i in range(len(iterable))]


data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]

print(heapsort(data))
print(heapsort2(data))
#输出
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

4.堆中元素可以是元组形式，主要用于任务优先级

from heapq import heappush, heappop

h = []
heappush(h, (5, 'write code'))
heappush(h, (7, 'release product'))
heappush(h, (1, 'write spec'))
heappush(h, (3, 'create tests'))
print(h)
print(heappop(h))
#学习中遇到问题没人解答？小编创建了一个Python学习交流群：725638078

[(1, 'write spec'), (3, 'create tests'), (5, 'write code'), (7, 'release product')]
(1, 'write spec')

上述操作流程如下：

1.当进行第一次push(5, ‘write code’)时
在这里插入图片描述

2.当进行第二次push(7, ‘release product’)时，符合堆的要求
在这里插入图片描述

3.当进行第三次push(1, ‘write spec’)时，
在这里插入图片描述

4.依据python的堆的最小堆特性，5>1 ，交换5和1
在这里插入图片描述

5.当进行最后依次push(3, ‘create tests’)时
在这里插入图片描述

6.依据python堆的最小堆特性，7>3，交换7与3
在这里插入图片描述

7.符合要求，因此结果为[(1, ‘write spec’), (3, ‘create tests’), (5, ‘write code’), (7, ‘release product’)],弹出元素则是堆顶元素，数字越小，优先级越大。

Python程序u猿
关注
Python 算法基础篇：堆和优先队列的实现与应用
小蓝枣的博客
07-25 759
堆和优先队列是常用的数据结构，它们在算法和程序设计中有着广泛的应用。本篇博客将重点介绍堆和优先队列的原理、实现以及它们在不同场景下的应用。我们将使用 Python 来演示堆和优先队列的实现，并通过实例展示每一行代码的运行过程。
python中的堆
技术无止境，人生仍探索。
04-27 3676
python中的堆以及堆操作 # heapqt提供了对应堆的支持，构建的是小顶堆 from heapq import * my_data = [7,6,3,2,9,0,1,5,4] # 对my_data应用堆属性，即堆化 heapify(my_data) print(my_data) # [0, 2, 1, 4, 9, 3, 7, 5, 6] # 添加一个元素，堆自动调整，继续满足小顶堆 heappush(my_data,0.5) print(my_data) # [0, 0.5, 1, 4, 2,
python heap_Python堆
weixin_39753747的博客
12-10 227
堆是一种特殊的树结构，其中每个父节点小于或等于其子节点。 然后它被称为最小堆(Min Heap)。 如果每个父节点大于或等于其子节点，则称它为最大堆(Max Heap)。 实施优先级队列是非常有用的，在该队列中，具有较高权重的队列项目在处理中具有更高的优先级。在本章中，我们将学习使用python实现堆数据结构。创建一个堆堆是通过使用python内建的名称为heapq的库创建的。 该库具有对堆数据结...
python中有 吗_python中有堆吗
weixin_39612110的博客
12-04 204
堆(英语：heap)是计算机科学中一类特殊的数据结构的统称；堆的定义：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。(推荐学习：Python视频教程)"ki<=k2i,ki<=k2i 1;或ki>=k2i,ki>=k2i 1.(i=1,2,…,[n/2])"这是标准的堆的定义，但是python 中并没有独立的堆类型，只是包含一些堆操作函数的模块...
python 中自带的堆模块heapq
高颜值的杀生丸(此博客转载自我的博客园)
02-28 216
import heapq my_heap = [] #使用列表保存数据 #网列表中插入数据，优先级使用插入的内容来表示，就是一个比较大小的操作，越大优先级越高 heapq.heappush(my_heap,[29,True,"xiaohong","asdfa"]) heapq.heappush(my_heap,[28,False,"xiaowang"]) heapq.heappu...
python实现堆排序的实例讲解
12-20
在Python中实现堆排序，可以使用内置的`heapq`库，或者自己构建堆并进行调整。上述代码提供了一个自定义的实现方式，主要包含以下几个函数： - `swap_param`：交换列表中两个指定位置的元素。 - `heap_adjust`：...
Python实现堆排序.rar
06-25
在Python中，可以使用内置的`heapq`模块来轻松实现堆排序，但这个示例可能是通过自定义函数来演示堆排序的步骤。在`Python实现堆排序.py`文件中，可能会包含以下代码片段： ```python def heapify(arr, n, i): ...
Python内置模块及说明
06-16
以下是一些重要的Python内置模块及其详细说明： 1. **calendar**: 提供了处理日历相关任务的功能，如打印日历、计算特定月份的天数等。 2. **datetime**: 包含日期和时间处理的类，如`datetime.datetime`用于表示...
python 堆和优先队列的使用详解
09-19
### Python堆和优先队列的使用详解 ...通过对内置类型、元组类型以及自定义类的实例演示，展示了如何有效地利用Python的堆和优先队列解决实际问题。希望读者能够掌握这些基础知识，并在实际项目中灵活运用。
python 堆
sinat_38195894的博客
05-05 225
基本把论文搞好啦 加上出去玩了玩 重新开始学习~！ 1、leetcode215 数组中第k大元素 （最小堆） import heapq class Solution(object): def findKthLargest(self, nums, k): """ :type nums: List[int] :type k: int ...
python-堆
weixin_42038527的博客
07-30 2829
堆的概念 ● 堆：一种特殊的完全二叉树结构 ▶ 大根堆：一棵完全二叉树，满足任一节点都比其孩子节点大 ▶ 小根堆：一棵完全二叉树，满足任一节点都比其孩子节点小 堆的性质 堆的性质——向下调整： ▶ 假设根节点的左右孩子树都是堆，但根节点不满足堆的性质 ▶ 可以通过一次向下的调整来将其变成一个堆 堆排序过程——农村包围城市的策略 ▶（1）建堆 ▶（2）得到堆顶元素，为最大元素 ...
python中的堆（Heap）
jakelihua
06-20 4404
堆（Heap）是一种特殊的完全二叉树数据结构，有两种类型：大顶堆和小顶堆。在大顶堆中，父节点的值大于或等于其子节点的值，而在小顶堆中，父节点的值小于或等于其子节点的值。堆作为一种重要的数据结构，在很多场景下提供了高效的解决方案。它具有良好的时间复杂度和灵活的应用性，因此在算法和软件开发中被广泛使用。库可以方便地进行堆的相关操作。除此之外，还可以自定义比较函数来实现大顶堆或特定要求的堆。库提供了一些函数来操作堆，如插入、删除和构建等。在Python中，可以使用。
python堆模块_python 的内置模块堆 heapq
weixin_31302227的博客
02-10 118
In [2]: h = []In [3]: h.append(1)In [4]: h.append(2)In [5]: h.append(3)In [6]: h.append(8)In [7]: h.append(5)In [8]: h.append(0)#用heapq 生成一个最小堆In [9]: heapq.heapify(h)In [10]: heapq.heappop()In [11]: ...
python中有堆吗？
Z_Silence的博客
12-13 407
堆（英语：heap)是计算机科学中一类特殊的数据结构的统称； 堆的定义：n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时，称之为堆。 （推荐学习：Python基础视频教程） 这是标准的堆的定义，但是python 中并没有独立的堆类型，只是包含一些堆操作函数的模块（heapq =heap+queue首字母），其实堆在python中属于一种特殊的列表； 简单的介绍一下heapq中的...
heapy() ：python自带的堆排序
dili8870的博客
03-19 1178
堆是一个二叉树，其中每个父节点的值都小于或等于其所有子节点的值。整个堆的最小元素总是位于二叉树的根节点。python的heapq模块提供了对堆的支持。 堆数据结构最重要的特征是heap[0]永远是最小的元素 1. heap为定义堆，item增加的元素 heapq.heappush(heap,item) >>> import heapq >&...
用python实现堆
不吃鱼的猫的博客
11-08 1463
堆是一种数据结构，它是一棵完全二叉树，且某个节点的值总是不大于或不小于其父节点的值；根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。根据完全二叉树的性质，若将堆中的数据至顶向下，从左向右的存在一个一维数组里面，则父节点的位置索引总是该节点位置索引减1再除2取整的结果，如下图所示。  若直接将一组数如 [8,5,2,9,3,7,1,4,6] 放入上图所示的二叉树（如下图），...
Python高级数据结构——堆（Heap）
最新发布
Echo_Wish的博客
11-30 4571
堆是一种重要的数据结构，通过支持高效的插入和删除操作，在实际应用中发挥着重要作用。在Python中，可以使用heapq模块轻松实现堆。堆的应用场景包括优先队列和堆排序等。通过理解堆的基本概念、实现方式和应用场景，您将能够更好地运用堆解决实际问题。
利用python自带的小根堆 LeetCode
weixin_40248634的博客
11-26 798
python 的 heapq 是小根堆，所以需要转化为大根堆会方便处理，即将数组取为负数。
深入理解Python堆排序算法实现
Python内置了堆操作相关的模块，最常用的模块是heapq。heapq模块实现了堆队列算法，提供了对堆结构进行操作的函数，如： - heapq.heappush(heap, item)：将item放入堆中 - heapq.heappop(heap)：弹出堆中最小元素 - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值