数据结构之堆（优先队列）c++

最新推荐文章于 2024-05-13 09:00:00 发布
最新推荐文章于 2024-05-13 09:00:00 发布
阅读量568 收藏
点赞数 1
分类专栏： 堆 优先队列 数据结构 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57541265/article/details/123292809
版权

数据结构之堆（优先队列）c++

什么是堆？

堆（优先队列）是“特殊”的队列，取出元素的顺序是按照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。
堆可以看成是一颗完全二叉树。既可以使用链表实现也可以使用数组实现。但是使用数组实现比较方便。其使用数组实现的一个堆如下图所示。
在这里插入图片描述
对应数组（在用数组为存储方式的结构中，数组下标为0的地方是不存放任何数据的）在这里插入图片描述
堆可以分为2种，一个是最大堆，另一个是最小堆
最大堆：父节点的值要比其两个子节点(如果存在)大。
最小堆：父节点的值要比其两个子节点(如果存在)小。

下面我们给出堆的结构描述以及堆的操作：

为了应对不同数据类型，在这里我们使用模板类，

template <class T>
class Heap
{

public:
//方便用户选择创建大堆还是小堆
    enum Way
    {
        GREATER,//大
        LESS//小
    };

private:
    T *array_heap;       //堆
    size_t current_size; //当前容量
    size_t max_size;     //最大容量
    Way flag;            //堆的标志(大堆/小堆)

public:
    explicit Heap(const int &Size);
    ~Heap();
    //输出堆内数据
    void print();
    //堆是否为空
    bool empty() const;
    //堆是否已满
    bool full() const;
    //出堆
    T delHeap();
    //插入数据
    void insert(const T &Data, Way way);
    //构造堆
    void createHeap(const T *Data_Array, const size_t &Size, Way way = Heap<T>::GREATER);

private:
    //小于
    bool less(const T &Left, const T &Right);
    //大于
    bool greater(const T &Left, const T &Right);
    //比较
    bool compare(const T &Left, const T &Right, Way way);
    //调整堆
    void adjust();
    //调整堆
    void adjust(Way way);
public:
    T &operator[](const int &location);
};

下面我们给出部分函数的定义（类外实现）


template <typename T>
Heap<T>::Heap(const int &Size) : max_size(Size), current_size(0), flag(Heap<T>::GREATER)
{
    //申请内存 0号位置不使用
    this->array_heap = new T[Size + 1];
    //内存是否申请成功
    assert(this->array_heap);
    //初始化数据
    for (int i = 0; i < Size; ++i)
    {
        this->array_heap[i] = 0;
    }
};

template <typename T>
Heap<T>::~Heap()
{
    if (this->array_heap)
    {
        delete[] this->array_heap;
    }
    this->array_heap = nullptr;
    this->current_size = this->max_size = 0;
}

//堆是否为空
template <typename T>
bool Heap<T>::empty() const
{
    return (this->current_size == 0);
}
//堆是否已满
template <typename T>
bool Heap<T>::full() const
{
    return (this->current_size == this->max_size + 1);
}

template <typename T>
T &Heap<T>::operator[](const int &Location)
{
    return (this->array_heap[Location]);
}

//小于
template <typename T>
bool Heap<T>::less(const T &Left, const T &Right)
{
    return (Left < Right);
}
//大于
template <typename T>
bool Heap<T>::greater(const T &Left, const T &Right)
{
    return (Left > Right);
}

//比较
template <typename T>
bool Heap<T>::compare(const T &Left, const T &Right, Heap<T>::Way way)
{
    if (way == this->GREATER)
    {
        return this->greater(Left, Right);
    }
    else
    {
        return (this->less(Left, Right));
    }
}
//输出堆内数据
template <typename T>
void Heap<T>::print()
{
    for (auto i = 1; i <= this->current_size; ++i)
    {
        std::cout << this->array_heap[i] << ' ';
    }
    std::cout << std::endl;
}

堆的构造

我们使用数组来构造一个堆，为了处理多个数据，我们的构造选择接受一个数组元素来初始化我们的堆（此函数为类内实现）

//构造堆
    void createHeap(const T *Data_Array, const size_t &Size, Way way = Heap<T>::GREATER)
    {
        this->flag = way; //标识堆
        if (Size > this->max_size)
        {
            return;
        }
        for (auto i = 0; i < Size; ++i)
        {
            this->insert(Data_Array[i], way);
        }
    }

堆的插入

大家应该已经注意到了，在我们构造堆的函数中，核心的操作其实就是插入，
***注意事项：***将元素插入到堆中的时候，不能改变堆的性质。
插入操作：
插入元素到堆中，首先我们将元素插入到数组最后一个元素的下一个位置(假设下标为i)，接下来我们要对该堆进行一个调整。

我们以大堆为例，假设我们要插入是数据是10，如图所示：

在这里插入图片描述
我们把10放在数组的最后面，我们可以看到此时10>9,这肯定已经违反了大堆的性质，所以我们要对其进行调整，调整的方式为，将10与他的父节点（parent）进行比较，如果值大于父节点，我们就把该节点与父节点进行交换，然后继续和其父节点比较，直到有序为止（注意：在调整过程中父节点下标不能到零，即>1）。（父节点下标的计算公式为：父节点下标=当前下标 / 2）
在这里插入图片描述
此时我们发现10<16（父节点），堆已经有序，所以不需要调整了

下面我们来看插入操作的代码实现：

 //插入数据
    void insert(const T &Data, Way way)
    {
        //堆是否已满
        if (this->full())
        {
            return;
        }
        //把数据插入到末尾
        this->array_heap[++this->current_size] = Data;
        //调整堆
        this->adjust(way);
    }

下面是插入操作的核心，即调整堆，让堆变得有序，

//调整堆
    void adjust(Way way)
    {
        auto curPos = this->current_size;    // curPos指向堆中最后一个节点位置
        auto max = this->array_heap[curPos]; //保存当前节点数据
          // curPos > 1 防止访问到0号位置
        while (curPos > 1 && this->compare(max, this->array_heap[curPos / 2], way))
        {
            this->array_heap[curPos] = this->array_heap[curPos / 2]; //向下过滤节点
            curPos = curPos / 2;
        }
        //将原数据插入
        this->array_heap[curPos] = max;
    }

在此，为了提高效率，我们并不使用交换两个数据元素的方式

这种调整堆的方式又称为向下过滤节点

堆的删除

删除操作针对与对顶元素也就是根节点，我们采用的删除方式是，拿掉根节点，把末尾节点放到原根节上面，如图所示：
在这里插入图片描述
此时我们发现，根节点的值明显小于其左右子节点的值（1<16,1<12），已经不满足大堆的性质，在此时，我们需要对该堆的进行调整，让他变得有序。
此时我们所用的调整方式与插入时不一样
这次我们要将根节点的值与其子节点进行比较，对其进行向下调整，即
将根节点与左右子节点进行比较，把大的值往上移动，直到堆有序为止（子节点下标=父节点下标 * 2）
如图所示：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
此时堆已经调整完毕

下面我们来看代码实现


//出堆
template <typename T>
T Heap<T>::delHeap()
{
    //判断堆是否为空
    if(this->empty())
    {
        return false;
    }
    //保存根节点元素
    auto item = this->array_heap[1];
    //将末尾元素放到根节点上面，堆的大小减一
    this->array_heap[1] = this->array_heap[this->current_size--] ;
    //调整堆
    this->adjust();
    //返回根节点元素
    return item;
}

下面是调整堆的代码实现


//调整堆
template <typename T>
void Heap<T>::adjust()
{
    //记录父节点和子节点下标位置
    size_t parent, child;
//保存根节点元素
    auto item=this->array_heap[1];
    
   for(parent=1;parent*2<this->current_size;parent=child)
   {
       child=parent*2;
       //比较左节点和右节点大小
       if(child<this->current_size&&this->compare(this->array_heap[child+1],this->array_heap[child],this->flag))
       {
           ++child;
       }
       //向下过滤节点
        if(this->compare(this->array_heap[child],item,this->flag))
        {
            this->array_heap[parent]=this->array_heap[child];
        }
   }
   //插入数据
   this->array_heap[parent]=item;
    

}

下面我们来进行测试：


int main()
{

    int arr[10] = {1,3,2,5,4,6,7,9,8,10};
    Heap<int> heap1(10);
    std::cout<<"最大堆"<<std::endl;
    //最大堆
    heap1.createHeap(arr,10,Heap<int>::GREATER);
    std::cout<<"堆内元素"<<std::endl;
    heap1.print();
    //删除
    heap1.delHeap();
    std::cout<<"删除后堆内元素"<<std::endl;
    heap1.print();
    //插入
    heap1.insert(20,Heap<int>::GREATER);
     std::cout<<"插入后堆内元素"<<std::endl;
    heap1.print();

    Heap<int>heap2(10);
    std::cout<<"最小堆"<<std::endl;
    //最小堆
    heap2.createHeap(arr,10,Heap<int>::LESS);
     std::cout<<"堆内元素"<<std::endl;
    heap2.print();
    //删除
    heap2.delHeap();
    std::cout<<"删除后堆内元素"<<std::endl;
    heap2.print();
    //插入
    heap2.insert(20,Heap<int>::LESS);
     std::cout<<"插入后堆内元素"<<std::endl;
    heap2.print();

    return 0;
}

这是输出结果
在这里插入图片描述
最后这是完整的代码（分文件）
头文件

#ifndef HEAP_H_
#define HEAP_H_
#include <assert.h>
#include <iostream>

template <class T>
class Heap
{

public:
    enum Way
    {
        GREATER,
        LESS
    };

private:
    T *array_heap;       //堆
    size_t current_size; //当前容量
    size_t max_size;     //最大容量
    Way flag;            //堆的表示(大堆/小堆)

public:
    explicit Heap(const int &Size);
    ~Heap();
    //输出堆内数据
    void print();
    //堆是否为空
    bool empty() const;
    //堆是否已满
    bool full() const;
    //出堆
    T delHeap();

    //插入数据
    void insert(const T &Data, Way way)
    {
        if (this->full())
        {
            return;
        }
        //把数据插入到末尾
        this->array_heap[++this->current_size] = Data;
        //调整堆
        this->adjust(way);
    }

    //构造堆
    void createHeap(const T *Data_Array, const size_t &Size, Way way = Heap<T>::GREATER)
    {
        this->flag = way; //标识堆
        if (Size > this->max_size)
        {
            return;
        }
        for (auto i = 0; i < Size; ++i)
        {
            this->insert(Data_Array[i], way);
        }
    }

private:
    //小于
    bool less(const T &Left, const T &Right);
    //大于
    bool greater(const T &Left, const T &Right);
    //比较
    bool compare(const T &Left, const T &Right, Way way);
    //调整堆
    void adjust();
    //调整堆
    void adjust(Way way)
    {
        auto curPos = this->current_size;    // curPos指向堆中最后一个节点位置
        auto max = this->array_heap[curPos]; //保存当前节点数据
                                             // curPos > 1 防止访问到0号位置
        while (curPos > 1 && this->compare(max, this->array_heap[curPos / 2], way))
        {
            this->array_heap[curPos] = this->array_heap[curPos / 2]; //向下过滤节点
            curPos = curPos / 2;
        }
        //将原数据插入
        this->array_heap[curPos] = max;
    }

public:
    T &operator[](const int &location);
};

template <typename T>
Heap<T>::Heap(const int &Size) : max_size(Size), current_size(0), flag(Heap<T>::GREATER)
{
    //申请内存 0号位置不使用
    this->array_heap = new T[Size + 1];
    //内存是否申请成功
    assert(this->array_heap);
    //初始化数据
    for (int i = 0; i < Size; ++i)
    {
        this->array_heap[i] = 0;
    }
};

template <typename T>
Heap<T>::~Heap()
{
    if (this->array_heap)
    {
        delete[] this->array_heap;
    }
    this->array_heap = nullptr;
    this->current_size = this->max_size = 0;
}

//堆是否为空
template <typename T>
bool Heap<T>::empty() const
{
    return (this->current_size == 0);
}
//堆是否已满
template <typename T>
bool Heap<T>::full() const
{
    return (this->current_size == this->max_size + 1);
}

template <typename T>
T &Heap<T>::operator[](const int &Location)
{
    return (this->array_heap[Location]);
}

//小于
template <typename T>
bool Heap<T>::less(const T &Left, const T &Right)
{
    return (Left < Right);
}
//大于
template <typename T>
bool Heap<T>::greater(const T &Left, const T &Right)
{
    return (Left > Right);
}

//比较
template <typename T>
bool Heap<T>::compare(const T &Left, const T &Right, Heap<T>::Way way)
{
    if (way == this->GREATER)
    {
        return this->greater(Left, Right);
    }
    else
    {
        return (this->less(Left, Right));
    }
}

//出堆
template <typename T>
T Heap<T>::delHeap()
{
    //判断堆是否为空
    if(this->empty())
    {
        return false;
    }
    //保存根节点元素
    auto item = this->array_heap[1];
    //将末尾元素放到根节点上面，堆的大小减一
    this->array_heap[1] = this->array_heap[this->current_size--] ;
    //调整堆
    this->adjust();
    //返回根节点元素
    return item;
}

//调整堆
template <typename T>
void Heap<T>::adjust()
{
    //记录父节点和子节点下标位置
    size_t parent, child;
//保存根节点元素
    auto item=this->array_heap[1];
    
   for(parent=1;parent*2<this->current_size;parent=child)
   {
       child=parent*2;
       //比较左节点和右节点大小
       if(child<this->current_size&&this->compare(this->array_heap[child+1],this->array_heap[child],this->flag))
       {
           ++child;
       }
       //向下过滤节点
        if(this->compare(this->array_heap[child],item,this->flag))
        {
            this->array_heap[parent]=this->array_heap[child];
        }
   }
   //插入数据
   this->array_heap[parent]=item;
    

}

//输出堆内数据
template <typename T>
void Heap<T>::print()
{
    for (auto i = 1; i <= this->current_size; ++i)
    {
        std::cout << this->array_heap[i] << ' ';
    }
    std::cout << std::endl;
}

#endif

main文件

#include<iostream>
#include "heap.h"

int main()
{

    int arr[10] = {1,3,2,5,4,6,7,9,8,10};
    Heap<int> heap1(10);
    std::cout<<"最大堆"<<std::endl;
    //最大堆
    heap1.createHeap(arr,10,Heap<int>::GREATER);
    std::cout<<"堆内元素"<<std::endl;
    heap1.print();
    //删除
    heap1.delHeap();
    std::cout<<"删除后堆内元素"<<std::endl;
    heap1.print();
    //插入
    heap1.insert(20,Heap<int>::GREATER);
     std::cout<<"插入后堆内元素"<<std::endl;
    heap1.print();

    Heap<int>heap2(10);
    std::cout<<"最小堆"<<std::endl;
    //最小堆
    heap2.createHeap(arr,10,Heap<int>::LESS);
     std::cout<<"堆内元素"<<std::endl;
    heap2.print();
    //删除
    heap2.delHeap();
    std::cout<<"删除后堆内元素"<<std::endl;
    heap2.print();
    //插入
    heap2.insert(20,Heap<int>::LESS);
     std::cout<<"插入后堆内元素"<<std::endl;
    heap2.print();

    return 0;
}

好了这就是以上数据结构之堆的所有内容，希望大家喜欢。
喜欢的话麻烦大家点个赞~在这里插入图片描述

晨曦松影
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中的堆
「止于纸扇」的博客
08-14 550
数据结构有关模板
数据结构 | 4. 堆与优先队列
明朗晨光的专栏
09-24 956
堆与优先队列实质上是同一种东西，可以认为优先队列是堆的别名。 1、完全二叉树 完全二叉树的性质： 如下的左右两个形式都可以表示完全二叉树，因为完全二叉树可以顺序编码，所以可以建立一个顺序结构进行存储，右边可以理解为代码表现形式。通常将 0 号位空出来，找某个节点的左右孩子时也是通过编号，比如 1 号位节点的左孩子为 (2∗1+1)=3(2 * 1 + 1) = 3(2∗1+1)=3 号节点，右孩子为 444 号节点。 2、堆 堆在思维逻辑上是一棵完全二叉树，但是堆之所以叫堆，因为它特有的性质：任何一个
数据结构——堆(C++)
Wiki~
11-13 8818
数据结构——堆 文章目录数据结构——堆堆与堆排序二叉树满二叉树完全二叉树二叉堆堆的存储堆的插入删除具体的实现堆排序 堆与堆排序 堆（heap）分为二叉堆、二项式堆、斐波那契堆，堆是非线性数据结构，相当于一维数组，有两个直接后继。堆又被称为优先队列，尽管名为优先队列，但堆并不是队列。因为队列遵循First in, First out，但是堆是按照元素的优先级取出元素。所以“堆”是实现调度器的理想数据...
C++之堆的详解
m0_72542983的博客
02-06 122
堆的详解
看动画轻松理解「 堆 」
weixin_34293902的博客
12-20 281
堆(heap)又被为优先队列(priority queue)。尽管名为优先队列，但堆并不是队列。 因为队列中允许的操作是先进先出（FIFO），在队尾插入元素，在队头取出元素。 而堆虽然在堆底插入元素，在堆顶取出元素，但是堆中元素的排列不是按照到来的先后顺序，而是按照一定的优先顺序排列的。 本文通过堆的实现、最小堆（最大堆）、堆的时间复杂度、优先队列的实现、堆排序来介绍「 堆 」。 堆的...
堆(heap)与优先队列（priority queue）
weixin_52575498的博客
03-25 3689
一、堆 1.堆定义： 如果这棵完全二叉树的任意结点的关键字小于或等于其左孩子和右孩子的关键字，则称之为小堆
深入理解C++中的堆：从基本概念到实际应用
最新发布
Lion_Long的博客
05-13 1371
堆是一种具有树形结构的数据结构，它遵循堆属性，即：每个节点必须小于其每个子节点。“堆”这个名字可能来自于这样一个事实：如果堆放一堆东西并希望它能保持平衡，人类更愿意把大的东西放在底部，小的东西放在顶部：请注意，这与包含动态分配对象的内存区域中的堆完全无关（与栈相对，栈也是一种数据结构的名称）。堆的一个最重要的特性是，其最小元素位于其根部，易于访问。在堆中，每个节点理论上可以有任意数量的子节点。但在STL中，堆的节点有两个子节点，因此在本文中将用堆来指代二叉堆。
C++数据结构详解——堆
热门推荐
qq_54169998的博客
11-02 1万+
1.堆的原理精讲 最大堆特点： 当然，也有最小堆，最小堆就是将最大堆反过来，根结点为最小值~ 堆是树中最有个性的树，他是用数组表示的树 。 2.在数组中快速创建堆算法 1.首先我们需要找到最后一个结点的父结点如图(a),我们找到的结点是 87，然后找出该结点的最大子节点与自己比较，若该子节点比自身大，则将两个结点交换。 图(a)中，87 比左子节点 95 小,则交换之。如图(b)所示 2.我们移动到第一步前一个父节点 93，如图(c)所示.同理做第一步的比较...
c++ heap (堆)
JIAN_ZANG1125的博客
10-09 3961
C++ STL中提供了不少和排序相关的算法，包括堆排序(heap_sort)、排序(sort)、稳定排序(stable_sort)、局部排序(partial_sort)，时间复杂度均为O(nlogn)。其中，对于堆排序，也提供了不少函数，像入堆push_heap、创建堆make_heap、出堆pop_heap，是否为堆is_heap等。首先要明确数据结构上堆的概念。对于一个迭代器区间上的元素，不管实际的数据结构如何，都可以逻辑上排成一个完全二叉树，如果树的每个父节点都不小于左右两个子节点，那么区间元...
数据结构——优先级队列和堆
xh1605004242的博客
02-01 2577
优先级队列、堆及其区别
【C++】二叉堆和优先队列
AliceK1008的博客
07-05 277
堆（Heap）是计算机科学中一类特殊的数据结构，通常是一棵完全二叉树（每个结点只有不超过两个子结点，只有最下边一层从右开始不缺少或连续缺少一段结点，其它层都是满的的树形结构）。堆的性质有：将根结点最大的堆叫做大根堆，根结点最小的堆叫做小根堆。常见的堆有二叉堆、斐波那契堆等。 左是小根堆，右是大根堆： 堆的定义如下：nnn 个元素的序列 A1,A2……Ai{A_1,A_2……A_i}A1​,A2​……Ai​当且仅当满足下关系时，称之为堆。 Ai≤A2i,Ai≤A2i+1A_i\leq A_{2i},A_i\
堆排序与优先队列(c++实现版)
RGBMarco的博客
04-23 711
形成堆： 首先形成堆,我们有两种处理(“上浮”和”下沉”) 上浮:在原堆尾添加元素时,通过比较添加元素和原堆(二叉树)中父节点关系,决定是否继续上浮 下沉:在原堆首添加元素时(此时添加元素是二叉树的根节点),通过比较父节点与左右节点,找出最大的节点,通过是否交换元素,判断是否需要继续下沉 上浮和下沉最坏情况都是lgn，其实就是和二叉树树高有关 T(n) = O(lgn) 总结:两种方法都...
【数据结构(C++实现)】：堆的实现与优先队列
bqw的博客
04-05 1264
一、       介绍 1.      堆是一种树形结构，使我们能够迅速确定包含最大值的结点。维持一个堆的代价低于维持一个有序数据集的代价。优先队列是一个从堆自然衍生出来的数据结构。 2.      大根堆和小根堆 堆是一颗二叉树，其中任何一个结点与其兄弟结点之间都没有必然的顺序关系，但它与其父结点有大小顺序关系。子结点比父结点小的堆称为大根堆，反之，子结点比父结点大的堆称为小根堆。   ...
堆和优先队列C++
__Miracle__
02-22 1753
堆 堆的典型应用, 优先队列 典型应用: 操作系统程序调用 医院排队, 有的病人病情比较严重, 先去看病 游戏里面英雄攻击范围的敌人, 动态优先选择 不使用0号索引,存储堆 #include <iostream> #include <algorithm> #include <string> #include <ctime> #include <cmath> #include <cassert> using name
Java中的优先级队列（一）
weixin_34055910的博客
11-20 202
为什么80%的码农都做不了架构师？>>> ...
堆的用法总结
陈实Yepper
12-22 2333
堆(heaps) 不是容器，而是一种特别的数据组织方式。堆一般用来保存序列容器。 堆很重要，很多不同的计算机进程中都使用了它们。为了弄明白堆是什么，首先需要明白树是什么，因此首先说明树这种数据结构是什么。 树是分层排列的元素或节点。每个节点有一个键，它是节点中所保存的对象，就如同链表中的节点。父节点是有一个或两个子节点的节点。一般父节点可以有任意个数的子节点，树中的父节点不需要有相同个数的子节点。...
【数据结构】堆（优先级队列）
SPMAX的博客
05-29 343
堆也叫优先级队列，是一种形状是完全二叉树的数据结构，一般用数组存储。 为什么叫优先级队列呢，因为这个数据结构分为两种堆，第一种叫小根堆，第二种叫大根堆 。小根堆，意思是在根结点上的数是这个完全二叉树里面最小值，然后所有的子树都是一个小根堆。同理，大根堆里面所有的子树都是大根堆，子树里面的根结点都是子树里面最大的树。 下面模拟实现一遍大根堆作为例子便于体会堆这个数据结构： 首先定义堆的核心：数组 1： 然后开始创建一个堆，思路是传入一个数组，将这个数组定义成一个完全二叉树形状的堆。 核心在
Heap的Array实现法
starwavelin的专栏
08-01 1107
总论Heap 逻辑上二叉树形状 物理上线性 array实现 这里做的是一个大根堆，涵盖方法有： insert(): insert a new element to the heap this invokes a help method called moveUp() cuz the inserted element may be larger than its parent,
堆（优先队列）
青萍之末的博客
05-24 708
一、堆 1、堆的特征   堆是什么？是一种特殊的完全二叉树，就像下面这棵树一样：   这棵二叉树有一个特点，就是所有父结点都比子结点要小。符合这样特点的完全二叉树我们称为最小堆。反之，如果所有父结点都比子结点要大，这样的完全二叉树称为最大堆。   我们对堆中的结点按层进行编号，该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是： 最大堆：arr[i] &amp;gt;= ...
理解数据结构：二叉堆与优先队列
"特殊的数据结构-堆.pptx" 堆是一种特殊的数据结构，尤其在计算机科学和算法设计中扮演着重要角色。在给定的文件中，主要讨论了两种类型的堆——最大堆（大根堆）和最小堆（小根堆），以及它们在解决特定问题，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值