堆排序和优先队列

最新推荐文章于 2021-06-29 23:21:42 发布
最新推荐文章于 2021-06-29 23:21:42 发布
阅读量332 收藏 2
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DRZ_2000/article/details/104635417
版权

堆和优先队列 (C语言实现)

一 引子

  相信大家都接触过二叉树，而二叉树中有一个特殊的树——完全二叉树，若我们从上到下，从左到右，将每一个结点从1开始编号，完成后，我们可以得到这样一个规律：若某个结点的编号是 i，那该结点的左孩子的编号是2 * i，右孩子的编号是 2 * i + 1，为此我们可以用数组来存储这棵完全二叉树。
  示意图如下：
完全二叉树 数组1完全二叉树 数组存储2
了解完全二叉树的这个性质之后，我们接着来了解堆排序和优先队列

二 大顶堆和小顶堆

  大顶堆：在二叉树中父结点的值比左右孩子的值大，但是左右孩子值彼此间的没有明确的大小关系。
  小顶堆：父结点的值小于左右孩子结点的值小，左右孩子之间的值同样没有大小关系。
  示意图如下：
堆
  显然，不论是大顶堆还是小顶堆都是一棵完全二叉树，所以完全可以用数组来存储。
  现在我们来看看在堆的基础上实现优先队列和堆排序！

三 优先队列

  优先队列，顾名思义，它是一个队列，但它区别于其他普通队列，普通队列的性质就是“先进先出”，而优先队列，是选择值最大或者是最小的元素优先出队列，故先进不一定先出， 关于普通队列的基本操作实现，请点击我。
  将元素插入优先队列中，本质上其实是就是插入到堆中，重要的是我们要根据插入元素值的大小进行调整，把它放到数组的恰当位置，使得整个优先队列的性质不被破坏，每次出队的都是当前队列中优先级最大或最小的元素。
  假设元素的值越大则优先级越高，越先出队列 (对应的就是大顶堆)。
 
  首先我们将元素放在数组的最后一个位置，若当前的下标是ind，那它父结点的编号是ind >> 1，此时我们比较该结点和父节点的值，若比父结点的值大，交换该结点和父结点的值，如此循环下去（从后向前），直到父结点的值更大或者当前结点已经是数组中的第一个结点，此时调整完整。
 
  现在将队首元素出队列，输出队首元素后，我们将数组中最后的元素放在原队首元素的位置，此时显然不满足大顶堆的性质，我们要进行调整。首先我们找到左右孩子中值较大的那个结点，将它和父结点的值进行调整，如此循环下去，直到当前结点的值比左右孩子的值都要大，或者该结点已经是叶子结点。
  示意图如下：
队列中插入元素
弹出队首元素实现代码为：

typedef struct priority_queue {
    int *data;
    int size, cnt;
} priority_queue;

//向优先队列p中插入val，成功返回1，失败返回0
int push(priority_queue *p, int val) {
    if (!p) return 0;
    if (p->cnt == p->size) return 0;
    p->cnt++;
    p->data[p->cnt] = val;  //向队列最后插入val
    int tmp = p->cnt;
    while (tmp >> 1 && p->data[tmp] > p->data[tmp >> 1]) {  //进行调整
        swap(p->data[tmp], p->data[tmp >> 1]);
        tmp >>= 1;
    }
    return 1;
}

//删除队首元素，成功返回1，失败返回0
int pop(priority_queue *p) {
    if (!p) return 0;
    if (empty(p)) return 0;
    int ret = p->data[1];
    p->data[1] = p->data[p->cnt--];  //将最后一个元素放在队首的位置
    int ind = 1;
    while (ind << 1 <= p->cnt) {  //从前到后进行调整
        int tmp = ind, l = 2 * ind, r = 2 * ind + 1;
        if (p->data[l] > p->data[tmp]) tmp = l;
        if (r <= p->cnt && p->data[r] > p->data[tmp]) tmp = r;
        if (tmp == ind) break;
        swap(p->data[ind], p->data[tmp]);
        ind = tmp;
    }
    return ret;
}

四 堆排序

  假设我们现在要升序排列，那么我们要用的是大顶堆
  排序的基本思路很简单：首先将数组构成大顶堆，之后我们可以确定整个数组中最大的元素就在顶端，也就是数组中的第一个位置，现在我们将最后一个元素和队首元素交换，之后再调整堆，得到一个大顶堆和放在数组最后位置的最大的元素，如此不断的循环，不断的将当前最大的数字放在数组的后面并且是从后往前放。直到整个数组完全有序，排序结束。
  示意图如下：
堆排序
关键代码为：

//从下标为ind的地方开始向后调整
void update(int *arr, int n, int ind) {
    while ((ind << 1) <= n) {  //当左孩子存在的时候
        int tmp = ind, lchild = ind * 2, rchild = lchild + 1;
        if (arr[tmp] < arr[lchild]) tmp = lchild;
        if (rchild <= n && arr[rchild] > arr[tmp]) tmp = rchild;  //若右孩子存在，且右孩子的值较大
        if (tmp == ind) break;
        swap(arr[tmp], arr[ind]);
        ind = tmp;
    }
}

void heap_sort(int *arr, int n) {
    arr--;
    for (int i = n >> 1; i >= 1; i--) {  //建成大顶堆
        update(arr, n, i);
    }
    for (int i = n; i > 1; i--) {  //将最大值交换到数组最后，并调整数组
        swap(arr[1], arr[i]);
        update(arr, i - 1, 1);
    }
}

五 总代码献上

堆排序
#include <iostream>
using namespace std;

void update(int *arr, int n, int ind) {
    while ((ind << 1) <= n) {
        int tmp = ind, lchild = ind * 2, rchild = lchild + 1;
        if (arr[tmp] < arr[lchild]) tmp = lchild;
        if (rchild <= n && arr[rchild] > arr[tmp]) tmp = rchild;
        if (tmp == ind) break;
        swap(arr[tmp], arr[ind]);
        ind = tmp;
    }
}

void heap_sort(int *arr, int n) {
    arr--;
    for (int i = n >> 1; i >= 1; i--) {
        update(arr, n, i);
    }
    for (int i = n; i > 1; i--) {
        swap(arr[1], arr[i]);
        update(arr, i - 1, 1);
    }
}

void output(int *arr, int n) {
    printf("arr(%d) = [", n);
    for (int i = 0; i < n; i++) {
        if (i) printf(" ");
        printf("%d", arr[i]);
    }
    printf("]\n");
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    int arr[MAX_OP + 5] = {0};
    for (int i = 0; i < MAX_OP; i++) {
        int val = rand() % 100;
        arr[i] = val;
    }
    output(arr, MAX_OP);
    heap_sort(arr, MAX_OP);
    output(arr, MAX_OP);
    return 0;
}
/*代码结果输出：
arr(20) = [18 41 93 46 19 94 51 4 7 39 46 65 59 54 53 29 42 38 87 16]
arr(20) = [4 7 16 18 19 29 38 39 41 42 46 46 51 53 54 59 65 87 93 94]
*/
优先队列
#include <iostream>
using namespace std;

#define swap(a, b) {\
    __typeof(a) __tmp = a;\
    a = b, b = __tmp;\
}

typedef struct priority_queue {
    int *data;
    int size, cnt;
} priority_queue;

priority_queue *init(int size) {
    priority_queue *p = (priority_queue *)malloc(sizeof(priority_queue));
    p->data = (int *)malloc(sizeof(int) * (size + 1));
    p->size = size;
    p->cnt = 0;
    return p;
}

int empty(priority_queue *p) {
    return p->cnt == 0;
}
int top(priority_queue *p) {
    return p->data[1];
}

int push(priority_queue *p, int val) {
    if (!p) return 0;
    if (p->cnt == p->size) return 0;
    p->cnt++;
    p->data[p->cnt] = val;
    int tmp = p->cnt;
    while (tmp >> 1 && p->data[tmp] > p->data[tmp >> 1]) {
        swap(p->data[tmp], p->data[tmp >> 1]);
        tmp >>= 1;
    }
    return 1;
}
int pop(priority_queue *p) {
    if (!p) return 0;
    if (empty(p)) return 0;
    int ret = p->data[1];
    p->data[1] = p->data[p->cnt--];
    int ind = 1;
    while (ind << 1 <= p->cnt) {
        int tmp = ind, l = 2 * ind, r = 2 * ind + 1;
        if (p->data[l] > p->data[tmp]) tmp = l;
        if (r <= p->cnt && p->data[r] > p->data[tmp]) tmp = r;
        if (tmp == ind) break;
        swap(p->data[ind], p->data[tmp]);
        ind = tmp;
    }
    return ret;
}

void output(priority_queue *p) {
    if (!p) return ;
    printf("priority_queue(%d) = [", p->cnt);
    for (int i = 0; i < p->cnt; i++) {
        if (i) printf(" ");
        printf("%d", p->data[i]);
    }
    printf("\n");
}

void clear(priority_queue *p) {
    if (!p) return ;
    free(p->data);
    free(p);
}

int main() {
    srand(time(0));
    #define MAX_OP 20
    priority_queue *p = init(MAX_OP);
    for (int i = 0; i < MAX_OP; i++) {
        int val = rand() % 100;
        push(p, val);
        printf("push %d into priority_queue\n", val);
    }
    printf("\n");
    printf("遍历输出数组元素：\n");
    for (int i = 0; i < MAX_OP; i++) {
        printf("%d ", p->data[i]);
    }
    printf("\n\n");
    printf("不断取队首元素并将其弹出队列：\n");
    for (int i = 0; i < MAX_OP; i++) {
        printf("%d ", top(p));
        pop(p);
    }
    printf("\n");
    clear(p);
    return 0;
}

/*代码输出结果如下：
push 50 into priority_queue
push 22 into priority_queue
push 32 into priority_queue
push 33 into priority_queue
push 81 into priority_queue
push 80 into priority_queue
push 34 into priority_queue
push 89 into priority_queue
push 47 into priority_queue
push 83 into priority_queue
push 52 into priority_queue
push 59 into priority_queue
push 18 into priority_queue
push 46 into priority_queue
push 3 into priority_queue
push 6 into priority_queue
push 27 into priority_queue
push 86 into priority_queue
push 93 into priority_queue
push 35 into priority_queue

遍历输出数组元素：
0 93 89 80 86 81 59 46 27 83 35 52 32 18 34 3 6 22 47 50 

不断取队首元素并将其弹出队列：
93 89 86 83 81 80 59 52 50 47 46 35 34 33 32 27 22 18 6 3
*/

 
加油，路漫漫其修远兮，我将天天敲代码！与君共勉。
 

DRZ_2000
关注
专栏目录
堆排序在优先队列的应用及其C代码示例
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-26 650
堆排序（Heap Sort）是一种基于比较的排序算法，它利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序通过建堆和不断调整堆的过程，达到排序的目的。而优先队列（Priority Queue）是一种抽象数据类型，它类似于普通的队列或栈数据结构，但每一个元素都有一个相关的值，称之为“优先级”。优先队列中的元素根据其优先级进行处理，优先级最高的元素最先得到处理。堆排序在优先队列的实现中发挥着重要作用，尤其是在需要
使用堆排序实现优先队列
盛夏与微风
07-12 1938
首先了解几个概念： 堆有序：在数组中，每个元素大于等于两个特定位置的元素。二叉树中，每个父节点的值要大于等于两个子节点的值 完全二叉树：每个节点的子节点个数为2或0 二叉堆：是一组能用堆有序的完全二叉树排序的元素，并在数组中按照二叉树的层序遍历顺序保存。 如果要将上图的二叉堆元素（节点数为N）保存在数组中，则需要创建一个长为N+1的数组，第0个元素不用，使用[1~N]保存节点。上述二叉堆按照层...
堆排序与优先队列
滴墨成殇的博客
01-30 236
1. 预备知识   (1) 基本概念         如图，（二叉）堆是一个数组，它可以被看成一个近似的完全二叉树。树中的每一个结点对应数组中的一个元素。除了最底层外，该树是完全充满的，而且从左向右填充。堆的数组A包括两个属性：A.length给出了数组的长度；A.heap-size表示有多少个堆元素保存在该数组中（因为A中可能只有部分位置存放的是堆的有效元素）。     由于堆的...
堆和堆的应用：堆排序和优先队列
weixin_30384217的博客
11-19 441
堆和堆的应用堆排序和优先队列 堆 堆的应用堆排序 堆的应用优先队列 堆的应用海量实数中一亿级别以上找到TopK一万级别以下的数集合 总结 references 堆和堆的应用：堆排序和优先队列 1.堆 堆(Heap)是一种重要的数据结构，是实现优先队列(Priority Queues) 首选的数据结构。由于堆有很多种变体，包括二...
浅谈算法和数据结构: 五 优先级队列与堆排序
weixin_33861800的博客
03-02 380
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。 在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue) 。 本文首先介绍优先级队列的定义...
python 堆和优先队列的使用详解
09-19
### Python堆和优先队列的使用详解 #### 一、Python堆的概念与应用 ##### 1.1 基础概念 **堆**是一种特殊的完全二叉树结构，其中每个节点的值都大于或等于（最大堆）或小于或等于（最小堆）其子节点的值。在...
【alg4-排序】优先队列
...
11-30 238
许多应用程序都需要处理有序的元素，但不一定要求它们全部有序，或是不一定要一次就将它们排序。很多情况下我们会收集一些元素，处理当前键值最大的元素，然后再收集更多的元素，再处理当前键值最大的元素，如此这般。 在这种情况下，一个合适的数据结构应该支持两种操作：删除最大元素和插入元素。这种数据类型叫做优先队列。 优先队列的一些重要的应用场景包括模拟系统，其中事件的键即为发生的时间，而系统需要按照时间顺序处理所有事件；任务调度，其中键值对应的优先级决定了应该首先执行哪些任务；数值计算，键值代表计算错误，而我们需要按照
堆排序&优先队列
qq_40804920的博客
05-08 231
1、堆 （二叉）堆是一个数组，它可以被近似看成是一颗完全二叉树。树上的每一个结点都对应数组的一个元素。除了最底层，该树是完全充满的，该树在数组中是从左向右填充的。表示堆的数组A通常包括两个属性：数组长度A.length和堆的元素个数A.heapSize。给定一个结点的下标i，可以知道它的父结点、左孩子和右孩子的下标分别为i/2、2i和2i+1。 ...
算法-优先队列与堆排序
weixin_34247032的博客
06-29 89
我们自己每天使用的电脑能同时运行多个应用程序，没有感觉到卡顿，电脑为每个应用程序的事件分配了一个优先级，移动端的手机也是，通常不管我们是在看电影，发短信只要有电话，电话绝对是优先级最高的。这个时候我们需要一种合理的数据结构删除最大元素和插入元素，我们可以称之为优先队列。实现这种优先队列最合适的数据结构可以通过经典的二叉堆来实现，相对于其他数据结构更高效。 优先队列 开始撸代码之前我们需要明白几...
堆、堆排序与优先队列
未见君子，忧心如醉
04-26 142
堆、堆排序与优先队列 堆(heap)   堆(Heap)是计算机科学中一类特殊的数据结构。堆通常用数组来实现。把堆近似看作一棵完全二叉树（最底层可能不是完全填满的，如下图），堆中结点的值总是不大于或不小于其父结点的值。   根结点最大的堆叫做最大堆或大根堆。   根结点最小的堆叫做最小堆或小根堆。   最小堆示例：   表示堆的数组AAA有两个属性：A.lengthA.lengthA.lengt...
堆排序 及 优先队列
oldbai001的专栏
07-04 638
思想 堆排序，顾名思义，就是基于堆。因此先来介绍一下堆的概念。 堆分为最大堆和最小堆，其实就是完全二叉树。最大堆要求节点的元素都要大于其孩子，最小堆要求节点元素都小于其左右孩子，两者对左右孩子的大小关系不做任何要求，其实很好理解。有了上面的定义，我们可以得知，处于最大堆的根节点的元素一定是这个堆中的最大值。其实我们的堆排序算法就是抓住了堆的这一特点，每次都取堆顶的元素，将其放在序列最后面，然后
【堆排序】优先队列
weixin_40794189的博客
06-29 435
优先队列1、堆1.1、堆维护1.2、建堆2、优先队列3、代码实现3.1、最大堆3.2、最小堆3.3、优先队列 1、堆 堆，又可以称为二叉堆，可以看做一个近似的完全二叉树，除了最下面一层，其余每层都是填满的，且是从左向右填充。 A表示一个堆，堆的相关概念： （1）A.length ：数组元素的个数。注意数组中不是所有元素都是有效的。 （2）A.heap-size：数组有效元素的个数，0<=A.heap-size<=A.length （3）PARENT(i)：给定一个下标 i，它的父节点是 i/2，
堆排序优先队列：操作与源码实现
本文档介绍了一种基于堆数据结构实现的优先队列，它主要用于在一组数据中维护一个具有最大优先级的元素集合。优先队列支持三个基本操作：搜索最大优先级的值（FindMax）、插入新元素（Insert），以及删除最大优先级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值