小顶堆数据结构C/C++代码实现

最新推荐文章于 2024-08-17 10:27:29 发布
最新推荐文章于 2024-08-17 10:27:29 发布
阅读量5.9k 收藏 13
点赞数 3
分类专栏： C/C++ ACM 文章标签： acm 算法 数据结构 小顶堆
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sm9sun/article/details/53837794
版权
ACM 同时被 2 个专栏收录
73 篇文章 5 订阅
订阅专栏
C/C++
49 篇文章 8 订阅
订阅专栏

相比队列和栈，很多人可能对堆的概念比较陌生，下面个给出堆的本质概念

一、堆也是一种数据结构，从实际应用意义来说，他是一种最优级别数据永远在第一位的队列，本文皆以最小值为例（小顶堆），即它变相是一种会永远保持最小值先出队的队列。

二、堆的本质是一颗完全二叉树，树根永远为整个树的最小值，这也就是实现了①永远保持最小值先出队的队列这样的功能。

三、为了便于实现②树根为整个树的最小值，堆中某个节点的值总是大于其父节点的值，这样当树根出队以后，次小的值一定是树根的左右子节点的其中一个。并且堆每个结点的左子树和右子树也都是一个堆。即：当某一个节点发生改变之后，取代他的只有可能和他有直系关系的节点。

四、为了保证②的完全二叉树性质，当堆有元素入队时，我们先将其放在队尾，然后再对其做出调整。当有元素出队时，我们把最后一个节点的元素先放在队首，然后再对其做出调整。

五、结合③和④，我们可以得出结论，无论是入队还是出队，我们实际做的操作都是在某一路径下完成若干次子节点与父节点交换的过程（我们称之为上浮和下沉）


下面再说一下堆支持的基本操作

①入队，插入新元素

②出队，删除堆顶

③查找最小值（堆顶），其实也可以查找其次小值

④建堆，这里建队有两种方法，一种是将值一个一个的插入，另一种是先变成一个堆，再对其进行多次调整。



下面具体讲实现方法，首先定义一个小顶堆

/*
 * 使用数组实现堆
 *
 * capacity 数组的最大容量
 * size     数组的长度
 * elements 堆中的元素存放的数组
 */
struct MinHeap
{
    int capacity;
    int size;
    ElementType *elements; 
};



入队：

先将要插入的结点x放在最底层的最右边，插入后满足完全二叉树的特点，然后把x依次向上调整到合适位置满足堆的性质，即“结点上浮”。

 for (i = ++pqueue->size; x < pqueue->elements[i / 2]; i /= 2)
            pqueue->elements[i] = pqueue->elements[i / 2]; //上浮
        pqueue->elements[i] = x;


出队：

树根出队，然后先把最后的叶子节点放在树根，再逐渐下沉到其合适的位置。

// 注意对节点进行下沉操作时，要判断该节点是有两个儿子还是一个儿子
    minElement = pqueue->elements[1];
    lastElement = pqueue->elements[pqueue->size--];
    for (i = 1; i * 2 <= pqueue->size; i = child)
    {
        child = i * 2;
         
        // 节点i只有一个儿子时必有i * 2 = pqueue->size
        if (child < pqueue->size && pqueue->elements[child] > pqueue->elements[child + 1])
            child++;
         
        if (lastElement < pqueue->elements[child])
            break;
        else
            pqueue->elements[i] = pqueue->elements[child]; 
    }
    pqueue->elements[i] = lastElement;
     
    return minElement; // 返回被删除的元素


查找

直接返回队首就可以了

 return pqueue->elements[1];



建堆：

第一种方法：建立一个空堆，然后将一组数据依次做插入操作，时间复杂度O(NlogN)

pqueue = initialize(n * 2);
for (int i = 0; i < n; i++)
    insert(arr[i], pqueue);


第二种方法：先将数组转化为堆，再进行调整，时间复杂度为O(N)

 for (i = 1; i <= n; i++)
        elements[i] = arr[i - 1];
    elements[0] = SentinelElement;//数组转换为堆
     
    for (i = n / 2; i > 0; i--)
        adjust(elements, n + 1, i);//从最后一个非叶子节点开始，做调整处理


void adjust(int *arr, int len, int i)
{
    int n = len - 1;
    int tmp;
if(i * 2 >n)                       //叶子节点跳出
return;
    if (i * 2 == n && arr[i] > arr[n]) // 只有左儿子的节点，并且左儿子比本节点的值要小，交换
    {
        tmp = arr[i];
        arr[i] = arr[n];
        arr[n] = tmp;
    }
    else // 有两个儿子的节点
    {
        if (arr[i * 2] > arr[i * 2 + 1]) // 右儿子较小
        {
            if (arr[i] > arr[i * 2 + 1]) // 如果本节点比右儿子大，交换
            {
                tmp = arr[i];
                arr[i] = arr[i * 2 + 1];
                arr[i * 2 + 1] = tmp;
adjust(arr, len, i * 2 + 1);
            }
        }
        else // 左儿子较小
        {
            if (arr[i] > arr[i * 2]) // 如果本节点比左儿子大，交换
            {
                tmp = arr[i];
                arr[i] = arr[i * 2];
                arr[i * 2] = tmp;
adjust(arr, len, i * 2 );
            }
        }
    }
}



再说一下堆排序，其实可以把他当作是原堆所有值都出队就好了。时间复杂度O(NlogN)

for (i = 1; i <= n; i++)
elements[i] = deleteMin(pqueue);
elements[0] = SentinelElement;





下面给出完整代码


MinHeap.h  头文件


#ifndef DataStructures_MinHeap_h
#define DataStructures_MinHeap_h

struct MinHeap;
typedef struct MinHeap * MinPriorityQueue;
typedef int ElementType;

// 初始化堆
MinPriorityQueue initialize(int maxElements);

// 销毁堆
void destroy(MinPriorityQueue pqueue);

// 清空堆中的元素
void makeEmpty(MinPriorityQueue pqueue);

// 插入操作
void insert(ElementType x, MinPriorityQueue pqueue);

// 删除最小者操作，返回被删除的堆顶元素
ElementType deleteMin(MinPriorityQueue pqueue);

// 查找最小者（堆顶）
ElementType findMin(MinPriorityQueue pqueue);

// 判断堆是否为空
int isEmpty(MinPriorityQueue pqueue);

// 判断堆是否满
int isFull(MinPriorityQueue pqueue);

// 通过一个数组来建堆，相当于将用数组实现的无序树转换为堆序树——插入法
MinPriorityQueue buildHeap_insert(int *arr, int n);
// 通过一个数组来建堆，相当于将用数组实现的无序树转换为堆序树——调整法
MinPriorityQueue buildHeap_percolate(int *arr, int n);

//堆排序
MinPriorityQueue buildHeap_sort(MinPriorityQueue pqueue);

// 打印堆
void printMinPriorityQueue(MinPriorityQueue pqueue);

#endif


MinHeap.cpp  实现函数


#include <stdio.h>
#include <stdlib.h>
#include "MinHeap.h"
 
/* 标记节点，类似于链表中的表头节点
 * 该值必须小于所有最小堆中的元素，设其值为-1
 */
#define SentinelElement -1
 
/*
 * 使用数组实现堆
 *
 * capacity 数组的最大容量
 * size     数组的长度
 * elements 堆中的元素存放的数组
 */
struct MinHeap
{
    int capacity;
    int size;
    ElementType *elements; // 堆的元素个数为size，实际上用来存储的数组的长度为size + 1，还包括一个sentinel元素
};
 
void PQueueNULLWarning()
{
    printf("Warning: Minimum Priority Queue is NULL");
}
 
void outOfSpaceFatalError()
{
    printf("Fatal Error: Out of space");
    abort();
}
 
MinPriorityQueue initialize(int maxElements)
{
    MinPriorityQueue pqueue;
     
    if (maxElements <= 0)
    {
        printf("Fail to initialize: maxElements <= 0");
        return NULL;
    }
     
    pqueue = (MinPriorityQueue)malloc(sizeof(struct MinHeap));
    if (pqueue == NULL)
        outOfSpaceFatalError();
     
    // 数组的第0个元素是个sentinel标记节点，计入数组容量中，但不计入capcaity或size中
    pqueue->size = 0;
    pqueue->capacity = maxElements;
    pqueue->elements =  (ElementType *)malloc(sizeof(ElementType) * (pqueue->capacity + 1));
    if (pqueue->elements == NULL)
        outOfSpaceFatalError();
    else
        pqueue->elements[0] = SentinelElement;
     
    return pqueue;
}
 
void destroy(MinPriorityQueue pqueue)
{
    if (pqueue != NULL)
    {
        // 在GNU99标准中，free(NULL)什么都不做直接返回，所以不用判断pqueue->elements是否为NULL
        free(pqueue->elements);
        free(pqueue);
    }
}
 
void makeEmpty(MinPriorityQueue pqueue)
{
    if (pqueue != NULL)
        pqueue->size = 0;
    else
        PQueueNULLWarning();
}
 
 
/*
 * 插入的时间复杂度为O(log N)，N为最小堆中的元素个数
 */
void insert(ElementType x, MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
        PQueueNULLWarning();
     
    if (isFull(pqueue))
    {
        printf("Fail to insert: Priority Queue is Full");
        return;
    }
    else
    {
        int i;
         
        for (i = ++pqueue->size; x < pqueue->elements[i / 2]; i /= 2)
            pqueue->elements[i] = pqueue->elements[i / 2]; //上浮
        pqueue->elements[i] = x;
    }
}
 
/*
 * 删除操作的平均时间为O(log N)
 */
ElementType deleteMin(MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
    {
        PQueueNULLWarning();
        return SentinelElement;
    }
     
    if (isEmpty(pqueue))
    {
        printf("Fail to delete: Priority Queue is Empty");
        return SentinelElement;
    }
     
    int i, child;
    ElementType minElement, lastElement;
     
    // 注意对节点进行下沉操作时，要判断该节点是有两个儿子还是一个儿子
    minElement = pqueue->elements[1];
    lastElement = pqueue->elements[pqueue->size--];
    for (i = 1; i * 2 <= pqueue->size; i = child)
    {
        child = i * 2;
         
        // 节点i只有一个儿子时必有i * 2 = pqueue->size
        if (child < pqueue->size && pqueue->elements[child] > pqueue->elements[child + 1])
            child++;
         
        if (lastElement < pqueue->elements[child])
            break;
        else
            pqueue->elements[i] = pqueue->elements[child]; 
    }
    pqueue->elements[i] = lastElement;
     
    return minElement; // 返回被删除的元素
}
 
/*
 * 执行时间：O(1)
 */
ElementType findMin(MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
    {
        PQueueNULLWarning();
        return SentinelElement;
    }
    else
        return pqueue->elements[1];
}
 
int isEmpty(MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
    {
        PQueueNULLWarning();
        return -1;
    }
    else
        return (pqueue->size == 0);
}
 
int isFull(MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
    {
        PQueueNULLWarning();
        return -1;
    }
    else
        return (pqueue->size == pqueue->capacity);
}
 
void adjust(int *arr, int len, int i)
{
    int n = len - 1;
    int tmp;

	if(i * 2 >n)                       //叶子节点跳出
		return;
    if (i * 2 == n && arr[i] > arr[n]) // 只有左儿子的节点，并且左儿子比本节点的值要小，交换
    {
        tmp = arr[i];
        arr[i] = arr[n];
        arr[n] = tmp;
    }
    else // 有两个儿子的节点
    {
        if (arr[i * 2] > arr[i * 2 + 1]) // 右儿子较小
        {
            if (arr[i] > arr[i * 2 + 1]) // 如果本节点比右儿子大，交换
            {
                tmp = arr[i];
                arr[i] = arr[i * 2 + 1];
                arr[i * 2 + 1] = tmp;
				adjust(arr, len, i * 2 + 1);
            }
        }
        else // 左儿子较小
        {
            if (arr[i] > arr[i * 2]) // 如果本节点比左儿子大，交换
            {
                tmp = arr[i];
                arr[i] = arr[i * 2];
                arr[i * 2] = tmp;
				adjust(arr, len, i * 2 );
            }
        }
    }
}
 
/*先将数组转化为堆，再进行调整，时间复杂度为O(N)

正确的证明方法应当如下：
具有n个元素的平衡二叉树，树高为㏒n，我们设这个变量为h。
最下层非叶节点的元素，只需做一次线性运算便可以确定大根，而这一层具有2^(h-1)个元素，我们假定O(1)=1，那么这一层元素所需时间为2^(h-1) × 1。
由于是bottom-top建立堆，因此在调整上层元素的时候，并不需要同下层所有元素做比较，只需要同其中之一分支作比较，而作比较次数则是树的高度减去当前节点的高度。因此，第x层元素的计算量为2^(x-1) × (h-x)。
又以上通项公式可得知，构造树高为h的二叉堆的精确时间复杂度为： 
S = 2^(h-1) × 1 + 2^(h-2) × 2 + …… +1 × (h-1) ①
通过观察第四步得出的公式可知，该求和公式为等差数列和等比数列的乘积，因此用错位想减发求解，给公式左右两侧同时乘以2，可知： 
2S = 2^h × 1 + 2^(h-1) × 2+ …… +2 × (h-1) ②

用②减去①可知： S =2^h × 1 - h +1 ③

将h = ㏒n 带入③，得出如下结论：

S = n - ㏒n +1 = O(n)

*/

MinPriorityQueue buildHeap_percolate(int *arr, int n)
{
    if (arr == NULL)
    {
        printf("Error: Array is NULL");
        return NULL;
    }
     
    MinPriorityQueue pqueue;
    pqueue = ( MinPriorityQueue)malloc(sizeof(struct MinHeap));
     
    if (pqueue == NULL)
        outOfSpaceFatalError();
    ElementType *elements = ( ElementType *)malloc(sizeof(ElementType) * (n + 1));
    if (elements == NULL)
        outOfSpaceFatalError();
     
    int i;
    for (i = 1; i <= n; i++)
        elements[i] = arr[i - 1];
    elements[0] = SentinelElement;
     
    for (i = n / 2; i > 0; i--)
        adjust(elements, n + 1, i);
     
    pqueue->elements = elements;
    pqueue->size = n;
    pqueue->capacity = n * 2;
     
    return pqueue;
}
 
/*
 * 通过n次插入元素建立堆，由于每次插入的平均执行时间为O(logN)，所以建堆平均时间为O(NlogN)
 */
MinPriorityQueue buildHeap_insert(int *arr, int n)
{
    MinPriorityQueue pqueue;
     
    if (arr == NULL)
    {
        printf("Array is NULL, fail to build heap");
        return NULL;
    }
     
    pqueue = initialize(n * 2);
    for (int i = 0; i < n; i++)
        insert(arr[i], pqueue);
     
    return pqueue;
}
 
/*
 *通过n次出队操作把其值输出到另一个堆里，时间复杂度O(NlogN)
 */
MinPriorityQueue buildHeap_sort(MinPriorityQueue pqueue)
{
	MinPriorityQueue pqueuetemp;
	if (pqueue == NULL)
	{
		PQueueNULLWarning();
	}


	int n=pqueue->size;

	pqueuetemp = ( MinPriorityQueue)malloc(sizeof(struct MinHeap));

	if (pqueuetemp == NULL)
		outOfSpaceFatalError();
	ElementType *elements = ( ElementType *)malloc(sizeof(ElementType) * (n + 1));
	if (elements == NULL)
		outOfSpaceFatalError();

	int i;
	for (i = 1; i <= n; i++)
		elements[i] = deleteMin(pqueue);
	elements[0] = SentinelElement;

	pqueuetemp->elements = elements;
	pqueuetemp->size = n;
	pqueuetemp->capacity = n * 2;


	return pqueuetemp;

}


void printMinPriorityQueue(MinPriorityQueue pqueue)
{
    if (pqueue == NULL)
    {
        PQueueNULLWarning();
        return;
    }
     
    if (pqueue->elements == NULL)
    {
        printf("Fail to print: Elements of priority queue is NULL");
        return;
    }
     
    if (isEmpty(pqueue))
    {
        printf("Empty Prioirty Queue\n");
        return;
    }
     
    printf("Priority Queue\n");
    for (int i = 1; i <= pqueue->size; i++)
        printf("Element[%d] = %d\n", i, pqueue->elements[i]);
    printf("\n");
}


main.cpp   主函数调用

#include <stdio.h>
#include <stdlib.h>
#include "MinHeap.h"

int main(int argc, const char * argv[])
{
	int a[5] = {5, 4, 3, 2, 1};
	MinPriorityQueue pqueue_ins = buildHeap_insert(a, 5);
	printMinPriorityQueue(pqueue_ins);
	MinPriorityQueue pqueue_per = buildHeap_percolate(a, 5);
	printMinPriorityQueue(pqueue_per);
	MinPriorityQueue pqueue_sort=buildHeap_sort(pqueue_ins);
	printMinPriorityQueue(pqueue_sort);
/*
	deleteMin(pqueue_ins);
	printMinPriorityQueue(pqueue_ins);
	deleteMin(pqueue_ins);
	printMinPriorityQueue(pqueue_ins);
	insert(9, pqueue_ins);
	printMinPriorityQueue(pqueue_ins);
	insert(1, pqueue_ins);
	printMinPriorityQueue(pqueue_ins);
	*/
	system("pause");
	return 0;
}


/*转载与http://www.2cto.com/kf/201404/293694.html*/


注：代码部分转载与http://www.2cto.com/kf/201404/293694.html，并对其代码做了一些修正与改进。





九日王朝
关注
专栏目录
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
C++大小顶堆实现、堆排序以及priority_queue
永不秃头的三三的博客
01-30 1032
C++大小顶堆实现、堆排序以及priority_queue学习总结
小顶堆操作
05-03
建堆 堆排序 小顶堆 算法学习用，有什么好的建议欢迎告诉我呀，先谢谢大家的帮助
数据结构——堆
最新发布
2301_80373479的博客
08-17 1843
带你探索堆的奥秘
C++ 实现小顶堆
qq_39846523的博客
10-23 1050
#include <algorithm> #include <cassert> using namespace std; template<typename Item> class MinHeap{ private: Item *data; int count; int capacity; void shiftUp(i...
【数据结构】C++实现小顶堆
weixin_45781252的博客
08-25 642
C++实现小顶堆 //Myheap.h #pragma once #include<iostream> #include<vector> using namespace std; //小顶堆 class MyHeap { public: MyHeap();//构造函数 MyHeap(vector<int>); void insert(int); void pop(); int top(); void assgin(vector<int>);
小顶堆的C++实现
大海鱼塘
09-28 4611
最小堆就一个特性，儿子比老子大，应该算是比较好实现的数据结构，一共就两个操作。 插入：插入到树的最后，然后往上升 删除：为了实现方便，普遍的做法是用最后一个node替换堆顶，然后把这个node往下降就行了。 其他如建树，更新等操作都是这两个操作的组合。 代码如下： #include #include using namespace std; class MinHeap { priv
C++ 手写自建小顶堆
weixin_44178960的博客
07-18 359
以最大（小）层结点为根结点的子树保有最大（小）堆性质根结点的键值为该子树结点键值中最大（小）项。，其中任一非终端节点的数据值均不大于（或不小于）其左子节点和右子节点的值。而最大-最小堆集结了最大堆和最小堆的优点，这也是其名字的由来。，即最大层结点的儿子属于最小层，最小层结点的儿子属于最大层。最大堆根结点的键值是所有堆结点键值中最大者。最小堆根结点的键值是所有堆结点键值中最小者。最大-最小堆是最大层和最小层交替出现的。的元素，两个子节点下标为。3.长度为n的堆数组，从。的元素，父节点下标为。...
heap.rar_数据结构_C/C++__数据结构_C/C++_
08-09
5. **C/C++实现**：展示如何用C/C++代码创建和操作堆，包括动态数组的使用、内存管理以及相关的函数实现，如`heapify()`, `insert()`, `extractMax()`或`deleteMin()`等。 6. **实例分析**：通过具体例子展示堆的...
【C/C++】大小顶堆（插入和删除）
weixin_52265611的博客
03-24 2140
只是一个鶸用来记录学习内容的文章罢了，如果能多少帮到你那真是太好了，发现错误欢迎指正。 堆总是满足一下特性： 1.堆中某个结点的值总是不大于或不小于其父结点的值。 2.堆总是一棵完全二叉树。 一般用数组描述堆结构并用下标对其进行操作。 完全二叉树的数组形式就是将节点按层依次放入数组中。 比如下图中的树 用数组描述就是这样的 由此不难发现： 若已知父节点下标x，则左孩子下标为x* 2+1，右孩子下标为x* 2+2。 若已知孩子下标为y，则其父节点下标为(y-1)/2。因为下标都是int类型所以右孩子按照此
数据结构C++代码（排序）
11-10
本资源“数据结构C++代码（排序）”提供了多种排序算法的实现，帮助我们深入理解这些经典算法的工作原理及其在C++中的应用。 首先，我们来看冒泡排序（Bubble Sort）。这是一种简单的排序算法，通过不断交换相邻的...
C++小顶堆的类模板实现
03-03
C++小顶堆的实现，其中用到了类模板的知识，代码附有详细注释，主函数中附上了测试代码。欢迎私信讨论！
C++实现数据结构排序代码
11-10
堆排序利用了堆这种数据结构，将待排序的序列构造成一个大顶堆或小顶堆，然后依次将堆顶元素与末尾元素互换并调整堆，直到所有元素都有序。堆排序的时间复杂度为O(n log n)，性能优于前面两种。 选择排序...
C++实现最小堆（小顶堆）及堆排序（最小堆实现降序排序）
o707191418的博客
07-29 1839
最小堆（小顶堆）是一种二叉树，树中每个节点都小于他的所有子节点，在最小堆的构建和维护过程中最重要的是**上浮(swim)和下沉(sink)**操作。 MinHeap.h #include <algorithm> /* 最小堆类*/ template<typename T> class MinHeap { private: T* data; int sz; size_t capicity; public: MinHeap(int sz); ~MinHeap(); .
用数组实现小顶堆（二叉堆）的C++代码
冒大烟的羊肉串的专栏
08-22 2069
#include #include using namespace std; class minHeap { private:     vector array;     int theSize; public:     minHeap()
数据结构之堆——C++实现大顶堆和小顶堆
weixin_43744293的博客
07-07 5965
大小顶堆的实现什么是大顶堆和小顶堆大小顶堆的底层实现代码实现小顶堆定义小顶堆类构造函数插入扩大堆数组容量删除析构函数代码实现大顶堆测试 什么是大顶堆和小顶堆 堆是一种完全二叉树。完全二叉树的定义：所有节点从上往下，从左往右的依次排列，不能有空位置，是为完全二叉树。下面是完全二叉树和不完全二叉树的示意图： 大顶堆定义：父节点都大于左右子节点。 小顶堆定于：父节点都小于左右子节点。 二者示意图如下： 大小顶堆的底层实现 一般来说，定义二叉树都是定义一个节点类，节点类中包含本节点的数据元素和两个节点指针，分别
C++最小堆和最大堆实现
weixin_54720578的博客
03-15 854
最大最小堆在c++中相关的函数是：它们包含在头文件中1）make_heap（建堆）在容器范围内，就地建堆，保证最大(小)值在所给范围的最前面，其他值的位置不确定。可以有两个参数，也可以有三个参数，前两个参数是指向开始元素的迭代器和指向结束元素的下一个元素的迭代器。第三个参数（谓词）是可选的，不选默认大顶堆。我们可以自定义比较函数来设定小顶堆2）pop_heap（取出）将堆顶(所给范围的最前面)元素移动到所给范围的最后，并且将新的最大(小)值置于所给范围的最前面。
C++ 堆、大顶堆、小顶堆、堆排序
琅嬛福地
11-11 5318
堆(heaps)不是容器，而是一种特别的数据组织方式。};};int id;} };} };return 0;
C/C++优先队列std::priority_queue实现大顶堆和小顶堆
UUUUTaossienUUUU的专栏
03-11 2714
C/C++优先队列std::priority_queue实现大顶堆和小顶堆
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值