二叉堆复习（包括d堆）

最新推荐文章于 2021-06-04 14:32:25 发布
最新推荐文章于 2021-06-04 14:32:25 发布
阅读量128 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/YuNanlong/p/6075720.html
版权

要期中考了……我真的是什么也不会啊，书都没看过TAT。

好吧整理一下二叉堆，这里就以最大堆为例好了。

首先二叉堆其实是一棵CBT，满足父节点的键值大于左右子节点的键值（wikipedia把这个叫键值，其实我也不知道该叫什么），并且左右子树也是一个二叉堆。二叉堆一般是用数组来存储的（斜堆、左式堆是用树的结构）。

如果根节点在数组下标1的位置的话，数组下标n的位置的节点的儿子坐标是2n和2n+1。如果根节点在下标为x的位置的话，记住这个结论就可以求得此情况下数组下标为n的位置的儿子的下标，我们可以先假设将根节点挪到下标为1的位置上，相当于整个堆向左移（x - 1）个位置，那么原来下标为n的位置移动后的下标是（n - （x - 1）），代入之前的公式可以求得移动后，下标为（n - （x - 1））的位置的两个儿子此时的下标为2（n - （x - 1））和2（n - （x - 1））+ 1，最后再将整个堆向右移（x - 1）个位置，得到在原先的堆中，下标为n的位置的节点的儿子的下标为2（n - （x - 1））+ （x - 1）和2（n - （x - 1））+ （x - 1）+ 1，即2n - x + 1和2n - x + 2。

如果根节点在数组下标为1的位置的话，数组下标为n的位置的节点的父节点坐标是floor（n ／ 2），这里的floor是下取整函数，用上面同样的思想可以求得当根节点下标为x时，下标为n位置的节点的父节点下标为floor（（n + x - 1）／ 2）。

如果是根节点下标为1的d堆，则下标位置为n的节点的父节点和最左子节点及最右子节点的下标值分别为：floor（（n + d - 2）／ d），（n - 1）d + 2，nd + 1。更一般的结果，节点下标为n的第k个孩子的下标为（n - 1）d + 1 + k。

如果二叉堆有n个节点，则堆的高度为floor（logn），这个和二叉树的性质是一样的。如果是d堆的话，则有floor（logd（n（d - 1）））。

如果二叉堆有n个节点，那么下标大于floor（n ／ 2）的位置的节点（即堆在数组中最后一个节点的父节点）均为叶节点，证明这个结论可以用反证法，假设下标大于floor（n ／ 2）的节点中有一个不是叶节点，那么这个节点的子节点的存储位置的下标必然大于n，而这个堆在数组中的最大下标已知是n，产生矛盾，这样就可以证明这个结论。而最大堆中的最小值也一定在某个叶节点中，因为非叶节点的子节点值一定比它自身小。

由无序数组构建堆

然后讲一下构建堆的操作。

由一个无序数组构建堆最直观的方法是将其一个个插入一个空树中，这样的方法是最low的，时间复杂度是O（NlgN）。

其次是利用Max-Heapify算法。Max-Heapify算法就是对任意一个节点，假设它的左右子树都已经满足堆序（如果无左右子树则认为其已经满足堆序，如果只有左子树则比较左子树即可），那么只要比较左右子树的根节点和自身的大小，如果三个节点也满足堆序那么就不需要做任何操作，如果不满足就交换三者中两者的位置使三者满足堆序并对相应的根节点被改变的那棵子树使用Max-Heapify算法进行调整，这样的算法如果用递归实现的话时间复杂度可以表示为 T ( N ) <= T (2 N / 3) + Θ (1)（因为对子树进行递归调用，子树最坏情况大约为2n／3个节点，即原来一整棵树的最后一层恰好是左半边全满的情况），解得为O（lgN）。

而如果对树的每一个节点均调用一次Max-Heapify，这样也还是比较浪费，因为可以知道节点总数为n的堆下标大于floor（n ／ 2）的位置的节点均为叶节点（上面有讲过这一点），叶节点可以认为是一个已经符合要求的二叉树，那么只需对非叶节点调用Max-Heapify就可以了，这样构建堆的时间复杂度为O（N）计算如下：

其中N是节点数，n是节点height。

下面是这种建堆算法的代码：

void Max_Heapify(int H[], int size, int root){
    int l_child = root * 2;
    int r_child = root * 2 + 1;
    
    if(l_child <= size&&r_child <= size){
        if(H[l_child] < H[r_child]&&H[root] < H[r_child]){
            swap(H, r_child, root);
            Max_Heapify(H, size, r_child);
        }
        else if(H[r_child] < H[l_child]&&H[root] < H[l_child]){
            swap(H, l_child, root);
            Max_Heapify(H, size, l_child);
        }
        else{
            return;
        }
    }
    else if(l_child <= size){
        if(H[root] < H[l_child]){
            swap(H, l_child, root);
            Max_Heapify(H, size, l_child);
        }
        else{
            return;
        }
    }
    else{
        return;
    }
}

void Build_Max_Heapify(int H[], int size){
    int i;
    
    for(i = size / 2; i >= 1; i--){
        Max_Heapify(H, size, i);
    }
}

插入节点

插入节点的时间复杂度是O（logN），注意循环中如果没有满足跳出循环的条件，tmp要整除2，代码如下：

void Insert(int H[], int size, int val){
    int tmp = size + 1;
    
    if(tmp >= MaxSize)
        return;
    while(tmp / 2 >= 1){
        if(H[tmp / 2] < val){
            H[tmp] = H[tmp / 2];
            tmp = tmp / 2;
        }
        else{
　　　　　　  break;
        }
    }
    H[tmp] = val;
}

当然插入节点也可以用Max-Heapify来实现：

void Insert_2(int H[], int size, int val){
    int i;
    
    if(size + 1 >= MaxSize)
        return;
    H[size + 1] = val;
    for(i = (size + 1) / 2; i >= 1; i = i / 2){
        Max_Heapify(H, size + 1, i);
    }
}

删除根节点

删除节点的时间复杂度是O（logN），注意如果最后tmp是某叶节点下标，则直接赋值并跳出循环，代码如下：

void Delete_Root(int H[], int size){
    int tmp = 1, val = H[size];
    
    while(1){
        if(tmp * 2 + 1 <= size - 1){
            if(H[tmp * 2] < H[tmp * 2 + 1]&&val < H[tmp * 2 + 1]){
                H[tmp] = H[tmp * 2 + 1];
                tmp = tmp * 2 +1;
            }
            else if(H[tmp * 2 + 1] < H[tmp * 2]&&val < H[tmp * 2]){
                H[tmp] = H[tmp * 2];
                tmp = tmp * 2;
            }
            else{
　　　　　　　　   break;
            }
        }
        else if(tmp * 2 <= size - 1){
            if(H[tmp * 2] > val){
                H[tmp] = H[tmp * 2];
                tmp = tmp * 2;
            }
            else{
　　　　　　　　   break;
            }
        }
        else{
　　　　　　  break;
        }
    }
　　H[tmp] = val;
}

当然删除节点也可以用Max-Heapify来实现： 

void Delete_Root_2(int H[], int size){
    H[1] = H[size];
    Max_Heapify(H, size - 1, 1);
}

调整节点的值

调整节点的值主要有增大和减小两种情况，增大节点值时，以该节点为根的子树一定符合堆序，所以只要向上延其祖先节点的路径调整堆序即可，减小节点值时，以该节点为根的子树不一定符合堆序，而整棵树的其余部分一定符合堆序，所以只要向下对子树调整堆序即可。代码就不写了，反正就是调用Max_Heapify。

删除任意节点

删除任意节点的算法和调整节点值的算法差不多，将数组最后一个节点的值移动到被删除节点的位置，如果该节点值变大了，则相当于使用增大节点值的算法，反之则相当于使用减小节点值的算法。

当然也可以使用增大节点值的算法将被删除节点的值变为无穷大，则其最终将出现在根节点位置上，最后再调用删除根节点的算法。

 

void Delete_Node(int H[], int index, int size){
    if(H[index] < H[size]){
        while(index / 2 >= 1){
            if(H[index / 2] < H[size]){
                H[index] = H[index / 2];
            }
            else{
                break;
            }
            index /= 2;
        }
        H[index] = H[size];
    }
    else{
        while(index * 2 <= size - 1){
            if(index * 2 + 1 <= size - 1&&H[index * 2] < H[index * 2 + 1]){
                if(H[index * 2 + 1] > H[size]){
                    H[index] = H[index * 2 + 1];
                    index = index * 2 + 1;
                }
                else{
                    break;
                }
            }
            else{
                if(H[index * 2] > H[size]){
                    H[index] = H[index * 2];
                    index = index * 2;
                }
                else{
                    break;
                }
            }
        }
        H[index] = H[size];
    }
}

 

合并二叉堆

合并操作并不是二叉堆所擅长的，左式堆和斜堆什么的会好一点，斐波那契堆我不会啊……事实上左式堆的插入和删除操作都是通过合并操作来实现的。合并二叉堆的话，有两种方法，一种是将第二个堆一个个的插入第一个堆，算法复杂度为O（MlogN），另一种是直接接在第一个堆的数组后面，再维护，算法复杂度是O（2M + N），这里注意一下直接接在后面依次赋值也是需要时间的，为O（M）。

最后是完整的测试代码：

//
//  main.c
//  Binary Heap
//
//  Created by 余南龙 on 2016/11/18.
//  Copyright © 2016年 余南龙. All rights reserved.
//

#include <stdio.h>
#define MaxSize 100

void swap(int H[], int a, int b){
    int tmp = H[a];
    
    H[a] = H[b];
    H[b] = tmp;
}

void Max_Heapify(int H[], int size, int root){
    int l_child = root * 2;
    int r_child = root * 2 + 1;
    
    if(r_child <= size){
        if(H[l_child] < H[r_child]&&H[root] < H[r_child]){
            swap(H, r_child, root);
            Max_Heapify(H, size, r_child);
        }
        else if(H[r_child] < H[l_child]&&H[root] < H[l_child]){
            swap(H, l_child, root);
            Max_Heapify(H, size, l_child);
        }
        else{
            return;
        }
    }
    else if(l_child <= size){
        if(H[root] < H[l_child]){
            swap(H, l_child, root);
            Max_Heapify(H, size, l_child);
        }
        else{
            return;
        }
    }
    else{
        return;
    }
}

void Build_Max_Heapify(int H[], int size){
    int i;
    
    for(i = size / 2; i >= 1; i--){
        Max_Heapify(H, size, i);
    }
}

int Initial(int H[]){
    int size = 0, val;
    
    while(1){
        scanf("%d", &val);
        if(-1 == val){
            break;
        }
        else{
            H[++size] = val;
        }
    }
    
    return size;
}

void Output(int H[], int size){
    int i;
    
    for(i = 1; i <= size; i++){
        printf("%d ", H[i]);
    }
    putchar('\n');
}

void Insert(int H[], int size, int val){
    int tmp = size + 1;
    
    if(tmp >= MaxSize)
        return;
    while(tmp / 2 >= 1){
        if(H[tmp / 2] < val){
            H[tmp] = H[tmp / 2];
            tmp = tmp / 2;
        }
        else{
            H[tmp] = val;
            break;
        }
    }
    if(tmp == 1){
        H[tmp] = val;
    }
}

void Insert_2(int H[], int size, int val){
    int i;
    
    if(size + 1 >= MaxSize)
        return;
    H[size + 1] = val;
    for(i = (size + 1) / 2; i >= 1; i = i / 2){
        Max_Heapify(H, size + 1, i);
    }
}

void Delete_Root(int H[], int size){
    int tmp = 1, val = H[size];
    
    while(1){
        if(tmp * 2 + 1 <= size - 1){
            if(H[tmp * 2] < H[tmp * 2 + 1]&&val < H[tmp * 2 + 1]){
                H[tmp] = H[tmp * 2 + 1];
                tmp = tmp * 2 +1;
            }
            else if(H[tmp * 2 + 1] < H[tmp * 2]&&val < H[tmp * 2]){
                H[tmp] = H[tmp * 2];
                tmp = tmp * 2;
            }
            else{
                H[tmp] = val;
                break;
            }
        }
        else if(tmp * 2 <= size - 1){
            if(H[tmp * 2] > val){
                H[tmp] = H[tmp * 2];
                tmp = tmp * 2;
            }
            else{
                H[tmp] = val;
                break;
            }
        }
        else{
            H[tmp] = val;
            break;
        }
    }
}

void Delete_Root_2(int H[], int size){
    H[1] = H[size];
    Max_Heapify(H, size - 1, 1);
}

void Delete_Node(int H[], int index, int size){
    if(H[index] < H[size]){
        while(index / 2 >= 1){
            if(H[index / 2] < H[size]){
                H[index] = H[index / 2];
            }
            else{
                break;
            }
            index /= 2;
        }
        H[index] = H[size];
    }
    else{
        while(index * 2 <= size - 1){
            if(index * 2 + 1 <= size - 1&&H[index * 2] < H[index * 2 + 1]){
                if(H[index * 2 + 1] > H[size]){
                    H[index] = H[index * 2 + 1];
                    index = index * 2 + 1;
                }
                else{
                    break;
                }
            }
            else{
                if(H[index * 2] > H[size]){
                    H[index] = H[index * 2];
                    index = index * 2;
                }
                else{
                    break;
                }
            }
        }
        H[index] = H[size];
    }
}

int main(){
    int H[MaxSize], size, val, index;
    
    printf("Input an array using -1 as an end:");
    size = Initial(H);
    Build_Max_Heapify(H, size);
    printf("Which number do you want to insert to the Heap:");
    scanf("%d", &val);
    Insert_2(H, size, val);
    size++;
    Output(H, size);
    printf("Delete the root:\n");
    Delete_Root_2(H, size);
    size--;
    Output(H, size);
    printf("Which node do you want to delete:");
    scanf("%d", &index);
    Delete_Node(H, index, size);
    size--;
    Output(H, size);
}

 

转载于:https://www.cnblogs.com/YuNanlong/p/6075720.html

weixin_30627341
关注
二叉树经典面试题
qq_29503203的博客
11-28 1006
求二叉树中最远的两个节点的距离，对于这样一个题经过画图分析总体来说有一下几种情况： 分析：我们可以考虑递归算法，进行后续遍历的同时，将每一个节点左右子树的距离通过传引用的方式将其带回，如果当前节点的左右子树距离大于前一节点的左右子树距离，那么就更新这个distance. 代码实现： template struct BinaryTreeNode { Binar
0x17.基础数据结构 - 二叉堆
繁凡さん的博客
05-19 522
目录0.AcWing 145. 超市 声明： 本系列博客是《算法竞赛进阶指南》+《算法竞赛入门经典》+《挑战程序设计竞赛》的学习笔记，主要是因为我三本都买了 按照《算法竞赛进阶指南》的目录顺序学习，包含书中的少部分重要知识点、例题解题报告及我个人的学习心得和对该算法的补充拓展，仅用于学习交流和复习，无任何商业用途。博客中部分内容来源于书本和网络（我尽量减少书中引用），由我个人整理总结（习题和代码可全都是我自己敲哒）部分内容由我个人编写而成，如果想要有更好的学习体验或者希望学习到更全面的知识，请于京东搜索
盘点那些必问的数据结构算法题之二叉堆
Java面试精选的博客
07-03 267
0 概述 本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 https://github.com/shishujuan/dsalg/tree/master/code/ds/heap 1 二叉堆定义 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(A) 表示数组 A 的长度，而 HEAP_SIZE(A) 则表示存放在A...
数据结构和算法面试题系列—二叉堆
weixin_34364071的博客
09-16 406
这个系列是我多年前找工作时对数据结构和算法总结，其中有基础部分，也有各大公司的经典的面试题，最早发布在CSDN。现整理为一个系列给需要的朋友参考，如有错误，欢迎指正。本系列完整代码地址在 这里。 0 概述 本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队...
数据结构 d-堆
weixin_33736832的博客
09-17 241
d-堆 二叉堆因为实现简单，因此在需要优先队列的时候几乎总是使用二叉堆。d-堆是二叉堆的简单推广，它恰像一个二叉堆，只是所有的节点都有d个儿子（因此，二叉堆又叫2-堆）。下图表示的是一个3-堆。注意，d-堆要比二叉堆浅得多，它将Insert操作的运行时间改进为。然而，对于大的d，DeleteMin操作费时得多，因为虽然树浅了，但是d个儿子中的最小者是必须找到的，如果使用标准算法，将使用d-1...
堆有关的面试题（后续补充）
丁香枝上，豆蔻梢头
05-15 856
//********************************************************* //面试题：N个数找出最大的前K个（N超级大） // //思路：用前K个数建个小堆，然后向后遍历其余数，凡是遇到比堆根节点大的， // 就替换根节点，然后向下调整，使之始终保持小堆，然后继续遍历， // 直至访问完数据。这样就将前K个大的数据全放在了堆中。 //
2018级数据结构复习资料_settlersfme_数据结构_数据结构复习_
09-29
首先，资料中包含了四个数据结构模拟题，分别命名为A、B、C、D，这些文档很可能包含了多项选择题、填空题、简答题和编程题等多种类型的问题。这些问题旨在测试学习者对栈、队列、链表、树、图、排序和查找等基本数据...
08 常用二叉树-堆(4学时).docx
10-29
1. 首先，将每个待编码的字符（例如，a, b, c, d, e）视为一个具有权值（频率）的二叉树根节点，权值表示字符出现的次数。在这个例子中，字符频率分别为4, 7, 5, 2, 9。 2. 将这些单节点的二叉树放入一个优先队列...
南昌航空大学数据结构复习资料.pdf
最新发布
05-10
- 小根堆是每个父节点的值都小于或等于其子节点的值的二叉堆。复习资料展示了如何调整非小根堆到小根堆的过程。 9. **有向图**： - 邻接矩阵表示图的边，复习资料要求根据矩阵画出有向图。 - 关键路径：在AOE网...
堆排序的时间复杂度分析：掌握其时间效率的关键，提升代码性能
它利用二叉堆这种数据结构的特性来进行排序，以达到高效地进行元素重排的目的。堆排序算法特别适合于那些需要处理大量数据，且对时间复杂度有一定要求的场景。 堆排序的核心优势在于它在最坏情况下的时间复杂度仍能...
d-堆
wwj_bupt
05-28 1264
《数据结构与算法分析——c语言描述》 第六章代码和二叉堆差不多，有意思的是父亲，儿子编号的推导。第i行，第j行节点（均从1开始）的编号推导： 前面i-1行的节点加起来：1+d1+d2+d3+……+di−2=1−di−11−d 1+d^1+d^2+d^3+……+d^{i-2}=\dfrac{1-d^{i-1}}{1-d} 然后加上剩下的，就是1−di−11−d+j\dfrac{1-d^{i-1}
leetcode刷题（剑指offer）_（二叉堆）_40最小的k个数字
weixin_39238424的博客
02-20 326
面试题40. 最小的k个数 输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 示例 1： 输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例 2： 输入：arr = [0,1,2,1], k = 1 输出：[0] 解答： 这是一道简单题。 最简单的做法是先sort，再取前k...
算法导论 — 思考题6-2 对d叉堆的分析
yangtzhou的专栏
12-08 1708
（对ddd叉堆的分析）ddd叉堆与二叉堆很类似，但（一个可能的例外是）其中的每个非叶结点有ddd个孩子，而不是仅仅222个。 　　a. 如何在一个数组中表示一个ddd叉堆？ 　　b. 包含nnn个元素的ddd叉堆的高度是多少？请用nnn和ddd表示。 　　c. 请给出EXTRACT-MAX在ddd叉最大堆上的一个有效实现，并用ddd和nnn表示出它的时间复杂度。 　　d. 给出INSERT在ddd...
算法导论第六章思考题6-2： 对d堆的分析
左手为你画情
05-28 972
/**************************************************************************************** * (1) 显然索引为i的节点的子节点为区间 [ d*(i-1)+2,d*(i-1)+d+1 ]; * (2) logdN; * (3) 见下面_adjust()函数，运行时间为：Θ(d*logdN)； 
数据结构和算法--堆
li_unit的博客
08-25 327
数据结构和算法是一种思想，理解了思想就是忘记了代码也能找回原来的记忆。 栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 堆（操作系统）：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS（操作系统）回收，分配方式倒是类似于链表。 堆（数据结构）：堆可以被看成是一棵树，如：堆排序。 栈（数据结构）：一种先进后出的数...
C语言实现二叉堆及应用
LHS的专栏
11-07 2063
前段时间学到二叉堆的应用，现在来总结一下。 目录 二叉堆的概念 二叉堆的存储 二叉堆基本操作 节点插入(上浮调整) 节点删除(下沉调整) 构建二叉堆 二叉堆基本应用 二叉堆应用于堆排序 二叉堆应用于优先队列 二叉堆的概念    二叉堆本质是一种完全二叉树，所以完全二叉树的特点和性质可以运用到二叉堆。二叉堆可分为最小堆和最大堆。   最小堆定义：最小堆的任何一个父节点的值，...
二叉堆的实现
MAX_VALUE的博客
06-04 229
二叉堆本质上是完全二叉树，分为最大堆和最小堆，二叉堆的根节点称为堆顶。 最大堆：任意父节点值大于或等于左右孩子节点的值。堆顶为整个堆的最大元素 最小堆：任意父节点值小于或等于左右孩子节点的值。堆顶为整个堆的最小元素 ...
算法导论6-2d叉堆分析
youdianluanluan的专栏
11-30 1545
d叉堆其实就是每个非叶结点有d个子女 (1)结点i的父亲结点编码:floor{(i − 2)/d + 1}     结点i的第j个孩子结点:d(i-1)+j+1 (2)含n个元素的d叉堆的高度:floor{logd[n(d-1)]} (3)Extract_Max同样是返回第一个元素，并通过Max_Heapify保持最大堆性质，不同的是在Max_Heapify里可能需要将待调整的元素与其
电子科技大学数据结构复习提纲
在电子科技大学计算机学院的数据结构复习提纲中，主要知识点包括： 1. **绪论**： - **数据结构**：数据组织方式的抽象表示，DS=(D,R)，其中D是数据元素的集合，R是数据元素间关系的集合。 - **基本数据结构**：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值