向上和向下建堆的时间复杂度

最新推荐文章于 2025-12-05 23:25:47 发布

原创最新推荐文章于 2025-12-05 23:25:47 发布 · 237 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构 #有问必答 #笔记

数据结构初阶专栏收录该内容

12 篇文章

订阅专栏

堆的向上和向下调整-优快云博客

1.向上建堆的时间复杂度 N*log2 N

回顾一下上节，向上调整的条件是啥？

除了我们插入的数据，其他的数据成堆

这个就是向上调整的使用条件

我们这个建堆是一个一个插入数据再进行调整

2.向下建堆的时间复杂度 N

回顾一下上节，向上调整的条件是啥？

就是我们把端点删除后，它的左右子孙端点会形成新的堆

其实从这个地方我们也可以看出来向下键堆的效率比向上建堆效率高

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

别动我的屎山代码

关注关注

8
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

向上or向下调整建堆的时间复杂度

shylyly_的博客

08-13

287

向上or向下调整建堆的时间复杂度的本质区别的讲解

堆，向下调整算法，向上调整算法，数组建堆算法，堆排序，建堆时间复杂度的推理

热门推荐

HanMeng的博客

03-15

5万+

目录：1.堆2.堆的实现2.1堆的向下调整算法(建小堆)2.2 堆向下调整算法(建小堆)实现2.3 数组建堆算法(建小堆)2.4 数组建堆算法(建小堆)实现2.5 堆排序(降序)2.6 堆排序(降序)实现2.7 建堆的时间复杂度 1.堆大根堆：所有父节点大于等于孩子节点小根堆：所有父节点小于等于孩子节点堆的性质： • 堆中某个节点的值总是不大于或不小于其父节点的值 • 堆总是一棵完全二叉树 2.堆的实现现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它

参与评论您还未登录，请先登录后发表或查看评论

自下而上建立堆时间复杂度推导

amixteli的博客

08-30

2079

建立堆的顺序是bottom-top的。正确的证明方法应当如下：具有n个元素的平衡二叉树，树高为㏒n，我们设这个变量为h。最下层非叶节点的元素，只需做一次线性运算便可以确定大根，而这一层具有2^(h-1)个元素，我们假定O(1)=1，那么这一层元素所需时间为2^(h-1) × 1。由于是bottom-top建立堆，因此在调整上层元素的时候，并不需要同下层所有元素做比较，只需要同其中之...

堆排序自下而上建立大根堆时间复杂度为O(n)的证明

USTC暖暖的博客

12-20

2926

建立大根堆时，设有n个记录的初始序列所对应的完全二叉树的深度为h,建初堆时，每个非终端结点都要自上而下进行＂筛选＂。由于第i层上的结点数小于等于i-1,且第i层结点最大下移的深度为h-i,每下移一层要做两次比较，所以建初堆时关键字总的比较次数为: h=⌊log2(n)⌋+1 h=\lfloor log_2(n)\rfloor+1h=⌊log2(n)⌋+1 2h≤n+12^h\leq n+1 2h≤n+1 ∑i=h−112i−1⋅2⋅(h−i)=∑i=h−112i(h−i) \sum_{i=h-1}^1 2

为什么建堆的时间复杂度是O(n)？

林下的码路

03-31

1683

原文：https://blog.youkuaiyun.com/LeoSha/article/details/46116959 先看下堆排序与快速排序的实现代码： #include<bits/stdc++.h> using namespace std; const int maxn=111; int a[maxn]; void quicksort(int a[],int l,int...

堆排序自下向上建堆和自上向下调整的时间复杂度

chengchaonan的博客

04-12

7090

堆排序分为因为初始化建堆的过程，是一个杂乱无序的数组构成的完全二叉树，所以需要从第一个非叶节点开始与它的叶子节点进行比较，然后移动。不是说每一层选一个根节点进行比较就可以了，是每一层的所有元素都要跟它的左右节点进行比较。这也就导致了它的时间复杂度不是logn,对于重建堆的过程，因为是从最上面的根节点开始进行左右节点的比较，选择一个较小的左节点或者有节点进行交换。而因为只破坏了一层的有序性，另外...

建堆时间复杂度

夏天的阳光吖的博客

04-27

1039

所以，F(H) = 2^(h-2)*1 + 2^(h-3)*2 + ...... + 2^3*(h-4) + 2^2*(h-3) + 2^1*(h-2) + 2^0*(h-1),F(H) = F(h1)+F(h2)+F(h3)+F(h4)+.......+F(h-1)+F(h) ,其中，F(h) = 每层结点个数 * 向下调整次数。所以，F(H) = 2^1*1 + 2^2*2 + 2^3*3 + ...... + 2^(h-2)*(h-2) + 2^(h-1)*(h-1) ,我们用。

C语言数据结构堆排序、向上调整和向下调整的时间复杂度的计算、TopK问题等的介绍

Farewell_me的博客

05-29

1622

C语言数据结构堆排序、向上调整和向下调整的时间复杂度的计算、TopK问题等的介绍C语言数据结构堆排序、向上调整和向下调整的时间复杂度的计算、TopK问题等的介绍。

【建堆算法：向上调整算法和向下调整算法的时间复杂度计算】

weixin_56235740的博客

12-30

677

本文主要详细计算了向上调整建堆和向下调整建堆两种算法的时间复杂度

面试考点--堆(向下调整算法，向上调整算法，建堆，堆排序)以及堆排序、建堆的时间复杂度分析(图文并茂)

zw的博客

03-12

2978

堆堆是一种完全二叉树，现实中通常使用顺序结构的数组来存储堆，此处的堆是一种数据结构(完全二叉树)，而不是虚拟进程空间中的那个堆(是操作系统用来管理内存的一个区域分段 )

建堆的时间复杂度计算

m0_63852255的博客

08-16

2262

建堆的时间复杂度计算。

数据结构--堆的要点、实现以及建堆时间复杂度证明

qq_53215123的博客

05-16

1090

文章目录堆排序要点总结建堆详细时间复杂度证明实现代码（python）小根堆测试代码（堆排序正确性测试）堆排序要点总结堆的两个要素：是完全二叉树并且父节点的值一定大于（大根堆）或小于（小根堆）它的左右孩子。所有的操作，仔细思考后会发现，都是为绕这两点在做功课。构建时使用的基础数据结构，一般使用数组模拟完全二叉树，模拟方法： 1号元素即为根节点对于一个编号为n的节点，其左子节点编号为 2n,其右子节点编号为 2n + 1，其父节点编号为 n // 2 如果总结点数为n，则

数据结构：红黑树

闲余知道

12-04

1092

数据结构：红黑树

数据结构：二叉树

闲余知道

12-04

345

数据结构：二叉树

数据结构：集合

闲余知道

12-02

566

数据结构：集合

数据结构--队列

最新发布

2301_78295956的博客

12-05

312

本文介绍了队列的基本概念、实现方式及应用场景。队列是一种先进先出（FIFO）的线性表，分为顺序队列（循环队列）和链式队列两种实现方式。顺序队列使用数组存储，通过模运算解决越界问题，需牺牲一个存储单元区分队空队满；链式队列动态扩展，无空间限制但需额外指针开销。文章对比了两种队列的特性，分析了它们在缓冲区管理、任务调度、算法实现等场景的应用，并强调了边界处理、线程安全等注意事项。两种队列的基本操作时间复杂度均为O(1)，顺序队列空间效率更高，链式队列灵活性更强。

从0开始学算法——第三天（数据结构的多样性）

2401_84407045的博客

12-01

822

本文旨在让大家深入理解数据抽象与数据结构类型的概念、特点及应用。通过本文，大家将学习以下内容：（1）数组（2）动态数组（3）链表（4）栈（5）队列（6）堆（7）集合（8）哈希（9）树（10）图

数据结构：栈

Yolo_TvT的博客

12-01

449

栈的介绍及代码实现

最小堆向下调整和向上调整的时间复杂度分析

12-28

### 最小堆调整的时间复杂度分析 #### 向上调整（Up-heap 或 Bubble-up）当向最小堆中插入一个新的元素时，通常会将新元素放置在堆的最后一个位置，随后执行向上调整操作以恢复堆性质。每次调整涉及比较并可能交换当前节点与其父节点。由于堆的高度 \( h \) 可表示为 \( \log_2(n+1)-1 \)[^2] ，其中 \( n \) 是堆中的元素数量，在最坏情况下，新加入的元素需要沿着路径一直移动到根部，因此向上调整的最大次数等于堆的高度减去一层： \[ T_{\text{up}} = O(\log_2{n}) \] 这意味着向上调整的操作时间随着输入规模的增长而呈对数增长趋势[^2]。 ```python def up_heapify(heap, index): parent_index = (index - 1) // 2 while index != 0 and heap[parent_index] > heap[index]: # Swap elements if child is smaller than its parent heap[parent_index], heap[index] = heap[index], heap[parent_index] # Move to the next level towards root index = parent_index parent_index = (index - 1) // 2 return heap ``` #### 向下调整（Down-heap 或 Sink-down）对于删除最小值后的重新排列或是直接构建初始堆的过程，可能会触发向下调整动作。此过程中，从根结点开始逐级向下检查子节点，并根据情况与较小的孩子互换位置直到满足堆特性为止。同样基于最大层数考虑，即使每一步都发生交换，总的步数也不会超过树高\( \log_2{(n+1)}\) 。然而实际应用中往往不需要走完全程就能完成修复工作，平均性能优于理论上限[^3]。 \[ T_{\downarrow} = O(\log_2{n}) \] 值得注意的是，尽管单次下调操作的时间开销是对数级别的，但在建立整个堆时，通过优化策略可以使得整体建堆效率达到线性级别，即 \(O(n)\)，而非简单的乘积关系 \(O(n\cdot\log_2{n})\) [^4]。 ```python def down_heapify(heap, start=0): size = len(heap) current_idx = start min_child_idx = get_min_child_index(heap, current_idx) while min_child_idx < size and heap[current_idx] > heap[min_child_idx]: # Exchange with smallest child when necessary heap[current_idx], heap[min_child_idx] = heap[min_child_idx], heap[current_idx] # Proceed deeper into tree structure current_idx = min_child_idx min_child_idx = get_min_child_index(heap, current_idx) return heap def get_min_child_index(heap, idx): left = 2 * idx + 1 right = 2 * idx + 2 smallest = idx if left < len(heap) and heap[left] < heap[smallest]: smallest = left if right < len(heap) and heap[right] < heap[smallest]: smallest = right return smallest ```