数据结构之堆(Heap)及其用途

最新推荐文章于 2025-07-15 21:05:50 发布
最新推荐文章于 2025-07-15 21:05:50 发布
阅读量1.2w 收藏 32
点赞数 14
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 heap 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a1459268562/article/details/53509548

本文采用图文码结合的方式介绍堆来实现优先队列

什么是优先队列？
队列是一种先进先出(FIFO)的数据结构。虽然，优先队列中含有队列两个字，但是，他一点也不像队列了。个人感觉，应该叫他优先群。怎么说那，一群守秩序(FIFO)的人去排队买东西当然是队列结构。但是，一群不守秩序的人去买东西，当然谁的拳头大谁就先结账。这个拳头的大小就是我们所谓的优先级。哎~我拳头不大~
优先队列的实现方式有：
1.线性表
2.堆(Heap)
3.左高树(Leftist Tree)

本文先从堆(Heap)开始讨论实现优先队列。

介绍堆之前，先介绍一种叫做最大树和最小树的数据结构：
最大（小）树：
1.根的值大（小）于等于所有子树中所有的值
2.子树也是最大（小）树

最大（小）堆:
1.完全二叉树 2.最大（小）树

首先，我们要清楚，最大堆中最大的元素一定出现在根上，最小的元素一定在树的叶子上；第二大的元素一定在第二层上等等。
其次，因为堆是完全二叉树，所以，使用数组描述这种结构最好不过了。

一个最大堆
上图是一棵最大堆。
我们想对这中数据结构进行插入、删除时，要如何完成？
插入（就是拉父亲，拉不拉得动就另一说了）：
1)当插入5时，因为完全树，所以5要出现在第四层的第三个位置上。5放到这之后，父元素仍然比他大，所以仍然可以构成堆。
插5以后的结果
2)当插入20时，同样，要出现在4层的第三个上。但是，这时，7比20小了，那么，就把7拿下来，在判断20是不是可以在原7的位置上，不行的话，往下拉父节点，去侵占父节点的位置。
要插入20
第一次拉父
第二次拉父
第三次拉父
插入时，每一层操作一次，最多操作height次
于是时间复杂度为O(log2n)

删除（当然是要删最大的元素了，也就是要删根）：

最大堆
这也是一个最大堆

删掉20时，我们首先由完全树的定义知，第4层的8的未知将消失，我们不妨把8先拿到根上，再进行堆的重构（在左右树都是堆的情况下）。
第一步
第二步
第三步
删除时，每一层最多被修改一次，于是最多修改height次。
时间复杂度时O(log2n)。

最大堆的初始化（对数组中的元素进行调序）：
想一下最大堆，我们要想调序，要从最下层开始，但是，叶子需要调吗？暂时不需要。一个单独的节点就可以看成是一个最大堆了。由最大堆的性质可知，后面⌈n/2⌉个元素是叶子。那么，我们就从第[n/2]个元素开始对其进行调序。

对数组{1,2,3,4,5,6,7,8,9,10,11}进行调序
初始化
叶子暂时是不需要重构的。从5开始，对5进行重构和上面的重构方法类似不赘述。对4重构、3、2、1。

分析时间复杂性：
对第i层的某元素进行重构时，最复杂就是 从这个元素到叶子上的一条路径的节点都被修改，时间复杂度为O(height-i+1)。
我们一共需要修改height-1层；且第i层最多有2i−1个元素。
于是，总时间复杂度为
O((height−i+1)∗(height−1)∗2i−1∀i∈1,2,3,...,height−1)=O(2h)=O(n)

============================================================================

古人云：“没有代码就是耍流氓。” 代码如下：

/*MaxHeap*/
#include"xcept.h"
#include<iostream>
using namespace std;

template<class T>
class MaxHeap{
public:
    MaxHeap(int _maxsize=10);
    ~MaxHeap(){  delete[] heap; };
    MaxHeap<T>& Insert(T& t);//将元素t插入最大堆
    MaxHeap<T>& Delete(T& t);//将最大堆的根删掉，返回到t中
    void Initialize(T t[], int _currSize, int _maxSize);//初始化最大堆
    void output();
    void Deactive();
private:
    int currentSize;
    int maxSize;
    T *heap;//数组存放
};
template <class T>
MaxHeap<T>::MaxHeap(int _maxsize){//构造函数
    currentSize = 0;
    maxSize = _maxsize;
    heap = new T[maxSize + 1];//第一个元素不使用
}
template <class T>
MaxHeap<T>& MaxHeap<T>::Insert(T& t){//将元素t插入最大堆
    if (currentSize == maxSize) //满了拒绝插入
        throw NoMem();
    int i = ++currentSize;
    while (i != 1 && t > heap[i / 2]){
        heap[i] = heap[i / 2];//拉下父亲来
        i = i / 2;
    }
    heap[i] = t;
    return *this;
}

template <class T>
MaxHeap<T>& MaxHeap<T>::Delete(T& t){//删除最大元素
    if (currentSize == 0){//堆是空的，拒绝
        throw OutofBounds();
    }
    t = heap[1];
    T tail = heap[currentSize--];

    //重构
    int i = 1;
    int ci = 2;//记录i的孩子
    while (ci<=currentSize)
    {
        //找最大的孩子
        if (ci<currentSize && heap[ci+1]>heap[ci]){
            ci = ci + 1;
        }
        //判断是不是可以在当前位置i
        if (tail > heap[ci]){//yes
            break;
        }
        //no
        heap[i] = heap[ci];//把最大的孩子拿上去

        i = ci; //判断位置下移
        ci = i * 2;//仍记录孩子
    }
    heap[i] = tail;
    return *this;
}
template <class T>
void MaxHeap<T>::Initialize(T t[], int _currSize, int _maxSize){
    delete[]heap;
    heap = t;
    maxSize = _maxSize;
    currentSize = _currSize;

    //重构
    for (int i = maxSize / 2; i > 0; i--){
        T data = heap[i];//对第i个元素进行重构
        int ci = i * 2;
        while (ci <= currentSize)
        {
            //找最大的孩子
            if (ci<currentSize && heap[ci + 1]>heap[ci]){
                ci = ci + 1;
            }
            //判断是不是可以在当前位置i
            if (data > heap[ci]){//yes
                break;
            }
            //no
            heap[ci/2] = heap[ci];//把最大的孩子拿上去

            //判断位置下移
            ci = ci * 2;//仍记录孩子
        }
        heap[ci/2] = data;
    }

}
template<class T>
void MaxHeap<T>::Deactive(){
    heap = 0;
}
template<class T>
void MaxHeap<T>::output(){
    for (int  i = 1; i <= currentSize; i++)
    {
        cout << heap[i] << " ";
    }
    cout << endl;
}
class NoMem{
public :
    NoMem(){}
};
class OutofBounds{
public:
    OutofBounds(){

    }
};

这样，我们保证了每次出”队列”的都是最大的元素。即有了优先性。

========================================================================
堆这种基本的出入模式，可以完成一个人人皆知的排序算法—-堆排序。这是一种排序快且稳定的算法。

用堆来实现排序，看下面的代码：

#include"MaxHeap.h"
template <class T>
void heapSort(T arr[],int currSize,int maxSize){
    MaxHeap<T> mh;
    mh.Initialize(arr, currSize, maxSize);
    for (int i = currSize; i >0; i--)
    {
        T temp;
        mh.Delete(temp);
        arr[i] = temp;
    }
    //不让mh删掉arr
    mh.Deactive();
    for (int i = 1; i <= currSize; i++)
    {
        cout << arr[i] << " ";
    }
}

调用

//第一个位置不放元素
    int x[20] = {0,4,2,3,8,9,1,5};
    heapSort(x, 7, 20);

结果
结果

分析一下时间复杂度：
创建最大堆：n
删掉一个元素：log2n
删掉全部的元素：n∗log2n
总的操作次数：n+n∗log2n
则总的时间复杂度****O(nlogn)（这是最快的排序了吧，好像是）

================================================================

同样，我们也可类似的给出最小堆的生成方法。

使用最小堆结构我们还可以实现一个特殊的树结构–哈弗曼树(Haffman Tree)。
哈弗曼树可以用来给文本压缩、也可以解决一些优化问题。介绍一下文本的压缩吧，其实压缩就是一种特殊的优化。

有一个文本若是由1000个字符组成，且字符只有a、b、c、d组成，那就有1000个字节，即8000位数据。
若是将a表示成00,b表示成01,c表示成10,d表示成11。那么，我们表示这一个文件只需要2000位，即250字节就可以表示。节省了四分之三的空间，是不是很爆炸。

那我们要是把编码改成a:0、b:1、c:00、d:01，是不是可以那，要是可以那我们这样来编码是不是更省空间啊。看下面的例子：
abaccd=>010000001，这是将文本压缩的方式，但是我们能不能从这种编码将文本解压缩回去啊？010000001=>?显然是不能的。
那么，我们就需要对编码进行限制，任意编码不能是其他编码的前缀。于是，二叉树这种结构就很好用了，将节点前往左孩子的路径上标0，前往右孩子的路径上标1，因为任意两个叶子的路径一定不会是前缀的关系。但是，有四个叶子的二叉树的结构有很多，我们要选择哪种啊？不难想，我们要是尽量把文本压缩的小，那么我们就要让出现越多的字符替换的长度越短。于是，我们要统计文本中的各个字符的数目。于是，我们就需要来决定每个不同频率字符在树中的位置了。

我们给出haffman tree树的定义：
记WEP为加权外部路径的长度。L(i)跟根到外部节点i的距离，F(i)到外部节点的i的权值（也就是我们的频率）。

WEP=∑i=1nL(i)∗F(i)

haffman tree就是对给定的频率建立的最小加权外部路径长度的二叉树。

进行文本压缩：
1.确定文本的字符数目。
2.构建字符对应的haffman tree
3.确定字符对应的haffman 编码
4.使用haffman 编码进行压缩

简单介绍一下如何构建一棵haffman tree：
1.将每一个字符建成二叉树的外部节点。
2.选取两棵权值最小的树进行合并。新树的权值为两个小树的权值之和。
3.重复2,直至剩下一棵树。

haffman tree的构建
最终结果

于是：我们可以得到haffman 编码
a:00
b:010
c:011
d:100
e:101
f:11

实现代码：

#Haffman.h#

#include"MinHeap.h"
#include"BinaryTree.h"
#include "Stack.h"
class HaffmanNode{
    //一个haffman tree的节点包含权值和二叉树
public:
    bool operator>(HaffmanNode& a){
        if (weight > a.weight)
            return true;
        else
            return false;
    }
    bool operator<(HaffmanNode& a){
        if (weight < a.weight)
            return true;
        else
            return false;
    }
    int weight;//权值
    BTree<int> btree;//二叉树
};
//创建haffman树
BTree<int>& haffman(int a[], int n){
    //a[1...n]为每一个字符的权值，n为有几个字符
    HaffmanNode *hnodes = new HaffmanNode[n + 1];//从第一个开始使用
    BTree<int> treeInHaff,zero;
    //将每个节点初始化成一个带权的haffman树
    for (int i = 1; i <= n; i++)
    {
        treeInHaff.makeTree(1,zero,zero);//1没有意义随便写
        hnodes[i].weight = a[i];
        hnodes[i].btree = treeInHaff;
    }

    //存放haffman树的最小堆，用来找最小的haffman树
    MinHeap<HaffmanNode> t(1);
    t.Initialize(hnodes, n, n);
    //合并两个最小haffman树,n个元素进行n-1次的合并
    for (int i = 1; i <n; i++)
    {
        //找出两个最小的
        HaffmanNode temp1;
        t.Delete(temp1);
        HaffmanNode temp2;
        t.Delete(temp2);

        //对这两棵树进行合并操作
        int data = temp1.weight + temp2.weight;
        treeInHaff.makeTree(1,temp1.btree, temp2.btree);//1没有意义，随便写

        HaffmanNode opResult;//两颗最小的树的合并结果
        opResult.btree = treeInHaff;
        opResult.weight = data;
        t.Insert(opResult);//一定要存回
    }
    HaffmanNode lastTree;
    //最后的一颗树就是结果
    t.Delete(lastTree);
    return lastTree.btree;
};

//显示构造的haffman tree的haffman编码
void show(BTNode<int> *t,Stack<int>& s){
    if (t)
    {
        //当左右都变成空了，我们就输出这时的01序列
        if (!t->lchild && !t->rchild)
        {
            s.showStatus();
        }
        else {
            s.push(0);//进入左孩子，标0
            show(t->lchild, s);
            int x;
            s.pop(x);
            s.push(1);//进入右孩子，标1
            show(t->rchild, s);
            s.pop(x);
        }

    }
}

#MinHeap.h#

#include<iostream>
using namespace std;

template<class T>
class MinHeap{
public:
    MinHeap(int _Minsize = 10);
    ~MinHeap(){ delete[] heap; };
    MinHeap<T>& Insert(T& t);//将元素t插入最大堆
    MinHeap<T>& Delete(T& t);//将最大堆的根删掉，返回到t中
    void Initialize(T t[], int _currSize, int _maxSize);//初始化最大堆
    void Deactive();//heap = 0
private:
    int currentSize;
    int maxSize;
    T *heap;//数组存放
};
template <class T>
MinHeap<T>::MinHeap(int _maxsize){//构造函数
    currentSize = 0;
    maxSize = _maxsize;
    heap = new T[maxSize + 1];//第一个元素不使用
}
template <class T>
MinHeap<T>& MinHeap<T>::Insert(T& t){//将元素t插入最大堆
    if (currentSize == maxSize) //满了拒绝插入
        throw NoMem();
    int i = ++currentSize;
    while (i != 1 && t < heap[i / 2]){
        heap[i] = heap[i / 2];//拉下父亲来
        i = i / 2;
    }
    heap[i] = t;
    return *this;
}

template <class T>
MinHeap<T>& MinHeap<T>::Delete(T& t){//删除最大元素
    if (currentSize == 0){//堆是空的，拒绝
        throw OutofBounds();
    }
    t = heap[1];
    T tail = heap[currentSize--];

    //重构
    int i = 1;
    int ci = 2;//记录i的孩子
    while (ci <= currentSize)
    {
        //找最小的孩子
        if (ci<currentSize && heap[ci + 1]<heap[ci]){
            ci = ci + 1;
        }
        //判断是不是可以在当前位置i
        if (tail < heap[ci]){//yes
            break;
        }
        //no
        heap[i] = heap[ci];//把最小的孩子拿上去

        i = ci; //判断位置下移
        ci = i * 2;//仍记录孩子
    }
    heap[i] = tail;
    return *this;
}
template <class T>
void MinHeap<T>::Initialize(T t[], int _arrCurr, int _arrMax){
    //_arrCurr传进数组的当前下标，_arrMax最大下表
    delete[]heap;
    heap = t;
    maxSize = _arrMax;
    currentSize = _arrCurr;

    //重构
    for (int i = maxSize / 2; i > 0; i--){
        T data = heap[i];//对第i个元素进行重构
        int ci = i * 2;
        while (ci <= currentSize)
        {
            //找最小的孩子
            if (ci<currentSize && heap[ci + 1]<heap[ci]){
                ci = ci + 1;
            }
            //判断是不是可以在当前位置i
            if (data < heap[ci]){//yes
                break;
            }
            //no
            heap[ci / 2] = heap[ci];//把最小的孩子拿上去

            //判断位置下移
            ci = ci * 2;//仍记录孩子
        }
        heap[ci / 2] = data;
    }

}
template<class T>
void MinHeap<T>::Deactive(){
    heap = 0;
}

#BinaryTree.h#

template<class T>
class BTNode{
public:
    BTNode(){ data = 0; lchild = 0; rchild = 0; }
    BTNode(T _data, BTNode *_lchild, BTNode *_rchild){ data = _data; lchild = _lchild; rchild = _rchild; }
    T data;
    BTNode *lchild;
    BTNode *rchild;
};
template <class T>
class BTree {
public:
    BTree(){ root = 0; }
    void makeTree(const T& data, BTree<T> &l, BTree<T> &r){
        root = new BTNode<T>(data, l.root, r.root);
        l.root = 0; r.root = 0;
    };
    BTNode<T> *root;
};

#stack.h#

#include<iostream>
using namespace std;
/*
使用数组来实现Stack
*/
template<class T>
class Stack{
public:
    Stack(int maxtop=20);
    ~Stack(){ delete[] element; }
    bool isEmpty(){ return _top == -1; };
    bool isFull(){ return _top == MaxTop - 1; };
    Stack<T>& push(const T& t);//入栈
    Stack<T>& pop(T& r);//出栈
    void showStatus();//显示栈的元素，从栈低
private:
    int _top; //记录栈顶的位置
    int MaxTop;//记录总的栈的大小
    T *element;//存放元素
};

template<class T>
Stack<T>::Stack(int maxtop){//构造函数
    element = new T[maxtop];
    MaxTop = maxtop;
    _top = -1;
}

template<class T>
Stack<T>& Stack<T>::push(const T& t){//入栈
    if (isFull())throw OutofBounds();
    _top++;
    element[_top] = t;
    return *this;
}
template<class T>
Stack<T>& Stack<T>::pop(T& r){//出栈
    if (isEmpty()) throw OutofBounds();
    r = element[_top];
    _top--;
    return *this;
}
template<class T>
void Stack<T>::showStatus(){
    //显示栈的元素,从栈低开始显示
    //因为我们是从根开始往里放的，那么，我们就要从下往上输出
    for (int i = 0; i <= _top; i++){
        cout << element[i] << " ";
    }
    cout << endl;
}

#xcept.h#

//定义了两个异常类
class NoMem{
public :
    NoMem(){}
};
class OutofBounds{
public:
    OutofBounds(){}
};

测试代码：

#include"xcept.h"
#include<iostream>
using namespace std;
#include"HaffmanTree.h"
void main(){
    //第一个位置不放元素的权值，第一个元素的权值放在x[1]
    int x[7] = { 0,1,2,4,5,6,7};

    BTree<int> tree = haffman(x,6);
    Stack<int> s(20);
    show(tree.root, s);
}

测试结果：
haffman 编码的结果

经过上面的代码，我们能生成haffman编码了。
相信有了编码，对屏幕前的你来说不能实现 压缩了。

==============================================================================
那么，我们想使用haffman树来解决优化问题也很简单，只需要把数组中的权值换成你要解决问题的权值（这个权值可能是需要你用一定的运算来算出）。我们就不对优化详细介绍了，因为，haffman编码的生成实际实际上就是优化问题。

4、堆（Heap）数据结构详解
vvv99的博客
06-22 28
本博客详细介绍了堆这一重要的树形数据结构，涵盖其基本概念、实现方式以及在算法设计中的广泛应用。内容包括堆的插入、删除、查找等操作的实现原理及时间复杂度分析，同时探讨了堆在优先队列、堆排序和数据压缩（如哈夫曼算法）中的典型应用场景。此外，还讨论了堆的动态调整策略和性能优化技巧，帮助读者全面理解和高效使用堆数据结构。
栈和堆：数据结构的基石与应用
candy的博客
11-09 1375
栈和堆作为重要的数据结构，在计算机编程和数据处理领域有着广泛而不可替代的作用。栈以其简单高效的后进先出操作和在函数调用、表达式求值等方面的应用，为程序执行过程中的局部数据管理和特定逻辑处理提供了便利的手段。
数据结构——堆的实现与应用
cainiaochufa2021的博客
06-23 1075
我们知道二叉树有两种存储结构：一种是链式结构，一种是数组结构。由于数组结构的特殊性，它通常被用来存储完全二叉树。而数组结构的完全二叉树中又有一个特殊的数据结构，那就是堆。这一节将介绍堆的实现和堆的应用。...
堆的应用
weixin_33873846的博客
11-29 366
1. 堆的应用一：优先级队列 优先级队列，顾名思义，它首先应该是一个队列。队列最大的特性就是先进先出，而在优先级队列中，数据的出队顺序则是按照优先级来，优先级高的先出队。 实现优先级队列的方法有很多，但是用堆来实现是最直接、最高效的。堆和优先级队列非常相似，一个堆就可以看作一个优先级队列。从优先级队列中取出优先级最高的元素，就相当于取出堆顶元素。 1.1. 合并有序小文件 假设我们有 100 个小...
希尔排序：突破传统排序的边界
最新发布
xienda的博客
07-15 702
希尔排序的核心在于先将整个待排序的记录序列分割成若干个子序列，分别进行直接插入排序。随着增量逐渐减小，子序列的长度慢慢增加，整个序列会变得越来越接近有序。当增量减至 1 时，整个序列就会被合并为一个，再进行一次直接插入排序，最终完成整个排序过程。希尔排序通过巧妙的分组策略，打破了传统插入排序的性能瓶颈，为排序算法的发展开辟了新的思路。，让数组先达到部分有序的状态，最后再进行一次插入排序，从而减少了元素移动的次数。的排序算法，因为在不同的子序列插入排序过程中，相同元素的相对顺序可能会发生改变。
【数据结构与算法】“堆”还能这样用_堆的应用
Dream_Y.ocean的博客
06-11 1002
💛 前情提要💛本章节是的的相关知识~接下来我们即将进入一个全新的空间，对代码有一个全新的视角~以下的内容一定会让你对有一个颠覆性的认识哦！！！❗以下内容以的方式实现，对于来说最重要的是哦❗以下内容干货满满，跟上步伐吧~作者介绍：堆排序Top-K问题💡堆排序：本质为选择排序的一种堆排序便是利用这种数据结构的思想进行排序✊如果有同学不太熟悉，可点击⌈跳转⌋补充知识再出发呀🔥 思想：❓思考： 如何利用进行排序 假如排，我们利用进行排序的话：我们建好一个小堆后，因为小堆的特性为的数在根节点处（最上面），我们....
【数据结构】堆的应用
soybeen的博客
02-11 223
public class Heap { private int n = 0; private int count = 0; int[] a;// 从角标1开始存储 public Heap(int n) { this.n = n; this.count = 0; a = new int[n]; } ...
堆(Heap) 浅析
浪漫不死的博客
02-05 1795
目录一、概念二、重要操作：向下调整 一、概念 堆逻辑上是一棵完全二叉树 堆物理上是保存在数组中 满足任意结点的值都大于其子树中结点的值，叫做大堆，或者大根堆，或者最大堆 满足任意结点的值都小于其子树中结点的值，则是小堆，或者小根堆，或者最小堆 堆的基本作用是，快速找集合中的最值 二、重要操作：向下调整 前提： 只有需要调整的位置不清楚，但其他位置已经满足堆的性质了。 array 代表存储堆的数组 size 代表数组中被视为堆数据的个数 index 代表要调整位置的下标 left 代表 index
C语言-堆（heap）的详解与实现
qq_42037383的博客
06-28 566
堆（Heap）是一种特殊的树形数据结构，通常用于实现优先队列。最大堆：父节点的值大于或等于任何一个子节点的值。最小堆：父节点的值小于或等于任何一个子节点的值。在堆中，树的每个节点的值都必须满足堆的性质。
【Python3教程】Python3基础篇之数据结构
No8g攻城狮的博客
04-12 373
Python 3 提供了多种内置的数据结构，这些数据结构对于编写高效简洁的代码至关重要。每种数据结构都有其特定的用途和优势。
深入浅出-掌握常见数据结构的应用与实现
一键难忘的博客
11-21 2332
本文深入浅出地介绍了常见的数据结构及其应用，帮助读者理解其基本概念、实现方式和实际用途。线性结构数组和链表：数组适合处理连续存储的数据，而链表提供了灵活的内存管理。链表在插入和删除操作上有优势，而数组则在随机访问方面具有更高的效率。栈和队列栈：后进先出（LIFO）的数据结构，广泛应用于递归函数调用、表达式求值等场景。队列：先进先出（FIFO）的数据结构，应用于任务调度、资源共享等。哈希表通过哈希函数将数据映射到特定位置，实现了快速的查找、插入和删除操作，广泛用于数据库索引、缓存机制等。树形结构。
【数据结构】堆（Heap）
HY3253531932的博客
06-12 771
kₙ₋₁ }，把它的所有元素按完全二叉树的顺序存储方式存储，在一个一维数组中，并满足：Kᵢ <= K₂ *ᵢ₊₁ 且 Kᵢ <= K₂ *ᵢ₊₂ (Kᵢ >= K₂ *ᵢ₊ ₁ 且 Kᵢ >= K₂ *ᵢ₊₂ ) i = 0，1，2…这便是一次简单的插入，但由于新插入的元素可能使得原先的堆结构发生改变（新插入的元素使原堆不再为大堆或者小堆），因此这里采用一种向上调整的算法，使得堆的性质不发生改变。如果父节点大于孩子节点则交换，并更新父节点与子节点的值（将原子节点给给父节点，再更新子节点）。
数据结构秘籍（四） 堆 （详细包含用途、分类、存储、操作等）
rc1596919047的博客
03-02 1202
插入元素：先将元素放置到元素末尾，再自底向上堆化，使末尾元素上浮。删除堆顶元素：将末尾元素放置堆顶，再自顶向下堆化，将堆顶元素下沉。也可以自底向上堆化，只是会产生空缺，浪费存储空间。最好采用自顶向下的堆化方式。
数据结构——堆
wosinihuo的博客
07-07 226
要出现前缀码，只要构造树的时候，让要编码的字符出现在树的叶节点上就好了，如果这个树还满足哈夫曼树的特点，那就是最优编码
数据结构有什么实际用处
weixin_34290000的博客
11-28 549
小弟最近在学习数据结构，对数据结构不太了解，学得似懂非懂的，请问各位高手，学习数据结构在软件开发中有什么实际的用处？ 转载于:https://blog.51cto.com/arkor/434854...
【数据结构与算法】之“堆”介绍
醉逍遥的博客
10-07 930
堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。堆中某个节点的值总是不大于或不小于其父节点的值。堆总是一棵完全二叉树。堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似 完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。索引堆是对堆这个数据结构的优化。索引堆使用了一个新的 int 类型的数组，用于存放索引信息。优化了交换元素的消耗。加入的数据位置固定，方便寻找。
浅谈数据结构—堆(heap)
mango_yang的博客
12-15 1093
提出这样一个问题： 输入一个序列a[1..n]进行m次操作 ·操作1:将x插入到数列中 ·操作2:输出最小值 ·操作3:将最小值删除 (n,m 先尝试按照普及组的思路去做 方法1:无序表维护 ·插入O(1) ·删除O(1) ·查询O(n) 方法2:有序表维护 ·插入O(n) ·删除O(n) ·查询O(1) 很显然线性结构已经不满足这道题目的要求，然而我们可以用堆(he
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值