【数据结构与算法】内部排序之三：堆排序（含完整源码）_堆排序原码-程序员宅基地

技术标签： 算法  堆排序  

转载请注明出处：http://blog.csdn.net/ns_code/article/details/20227303


前言

    堆排序、快速排序、归并排序（下篇会写这两种排序算法）的平均时间复杂度都为O（n*logn）。要弄清楚堆排序，就要先了解下二叉堆这种数据结构。本文不打算完全讲述二叉堆的所有操作，而是着重讲述堆排序中要用到的操作。比如我们建堆的时候可以采用堆的插入操作（将元素插入到适当的位置，使新的序列仍符合堆的定义）将元素一个一个地插入到堆中，但其实我们完全没必要这么做，我们有执行操作更少的方法，后面你会看到，我们基本上只用到了堆的删除操作，更具体地说，应该是删除堆的根节点后，将剩余元素继续调整为堆的操作。先来看二叉堆的定义。

二叉堆

    二叉堆其实是一棵有着特殊性质的完全二叉树，这里的特殊性质是指：

    1、二叉堆的父节点的值总是大于等于（或小于等于）其左右孩子的值；

    2、每个节点的左右子树都是一棵这样的二叉堆。

    如果一个二叉堆的父节点的值总是大于其左右孩子的值，那么该二叉堆为最大堆，反之为最小堆。我们在排序时，如果要排序后的顺序为从小到大，则需选择最大堆，反之，选择最小堆，这点通过后面对堆排序分析，你会有所体会。

堆排序

    由二叉堆的定义可知，堆顶元素（即二叉堆的根节点）一定为堆中的最大值或最小值，因此如果我们输出堆顶元素后，将剩余的元素再调整为二叉堆，继而再次输出堆顶元素，再将剩余的元素调整为二叉堆，反复执行该过程，这样便可输出一个有序序列，这个过程我们就叫做堆排序。

    由于我们的输入是一个无序序列，因此要实现堆排序，我们要先后解决如下两个问题：

    1、如何将一个无序序列建成一个二叉堆；

    2、在去掉堆顶元素后，如何将剩余的元素调整为一个二叉堆。

    针对第一个问题，可能很明显会想到用堆的插入操作，一个一个地插入元素，每次插入后调整元素的位置，使新的序列依然为二叉堆。这种操作一般是自底向上的调整操作，即先将待插入元素放在二叉堆后面，而后逐渐向上将其与父节点比较，进而调整位置。但正如前言中所说，我们完全用不着一个节点一个节点地插入，那我们要怎么做呢？我们需要先来解决第二个问题，解决了第二个问题，第一个问题问题也就迎刃而解了。

    调整二叉堆

    要分析第二个问题，我们先给出以下前提：

    1、我们排序的目标是从小到大，因此我们用最大堆；

    2、我们将二叉堆中的元素以层序遍历后的顺序保存在一维数组中，根节点在数组中的位置序号为0。

    这样，如果某个节点在数组中的位置序号为i，那么它的左右孩子的位置序号分别为2i+1和2i+2。

    为了使调整过程更易于理解，我们采用如下二叉堆来分析（注意下面的分析，我们并没有采用额外的数组来存储每次去掉的堆顶数据）： 

        

    这里数组A中元素的个数为8，很明显最大值为A0，为了实现排序后的元素按照从小到大的顺序排列，我们可以将二叉堆中的最后一个元素A7与A0互换，这样A7中保存的就是数组中的最大值，而此时该二叉树变为了如下情况：

   

    为了将其调整为二叉堆，我们需要寻找4应该插入的位置。为此，我们让4与它的孩子节点中最大的那个，也就是其左孩子7，进行比较，由于4<7,我们便把二者互换，这样二叉树便变成了如下的形式：

    接下来，继续让4与其左右孩子中的最大者，也就是6，进行比较，同样由于4<6，需要将二者互换，这样二叉树变成了如下的形式：


    这样便又构成了二叉堆，这时候A0为7，是所有元素中的最大元素。同样我们此时继续将二叉堆中的最后一个元素A6和A0互换，这样A6中保存的就是第二大的数值7，而A0就变为了3，形式如下：

    为了将其调整为二叉堆，一样将3与其孩子结点中的最大值比较，由于3<6，需要将二者互换，而后继续和其孩子节点比较，需要将3和4互换，最终再次调整好的二叉堆形式如下：


    一样将A0与此时堆中的最后一个元素A5互换，这样A5中保存的便是第三大的数值，再次调整剩余的节点，如此反复，直到最后堆中仅剩一个元素，这时整个数组便已经按照从小到大的顺序排列好了。

    据此，我们不难得出将剩余元素继续调整为二叉堆的操作实现代码如下（同前面两篇博文中一样，我们不需每次比较后都交换元素位置，代码中可以再次体会到这点）：

[cpp]  view plain   copy
  1. /* 
  2. arr[start+1...end]满足最大堆的定义， 
  3. 将arr[start]加入到最大堆arr[start+1...end]中， 
  4. 调整arr[start]的位置，使arr[start...end]也成为最大堆 
  5. 注：由于数组从0开始计算序号，也就是二叉堆的根节点序号为0， 
  6. 因此序号为i的左右子节点的序号分别为2i+1和2i+2 
  7. */  
  8. void HeapAdjustDown(int *arr,int start,int end)  
  9. {  
  10.     int temp = arr[start];  //保存当前节点  
  11.     int i = 2*start+1;      //该节点的左孩子在数组中的位置序号  
  12.     while(i<=end)  
  13.     {  
  14.         //找出左右孩子中最大的那个  
  15.         if(i+1<=end && arr[i+1]>arr[i])    
  16.             i++;  
  17.         //如果符合堆的定义，则不用调整位置  
  18.         if(arr[i]<=temp)   
  19.             break;  
  20.         //最大的子节点向上移动，替换掉其父节点  
  21.         arr[start] = arr[i];  
  22.         start = i;  
  23.         i = 2*start+1;  
  24.     }  
  25.     arr[start] = temp;  
  26. }  
    这样，将已经建好的二叉堆进行排序的代码如下：

[cpp]  view plain   copy
  1. //进行堆排序  
  2. for(i=len-1;i>0;i--)  
  3. {  
  4.     //堆顶元素和最后一个元素交换位置，  
  5.     //这样最后的一个位置保存的是最大的数，  
  6.     //每次循环依次将次大的数值在放进其前面一个位置，  
  7.     //这样得到的顺序就是从小到大  
  8.     int temp = arr[i];  
  9.     arr[i] = arr[0];  
  10.     arr[0] = temp;  
  11.     //将arr[0...i-1]重新调整为最大堆  
  12.     HeapAdjustDown(arr,0,i-1);  
  13. }  

    建立二叉堆

    搞懂了第二个问题，那么我们回过头来看如何将无序的数组建成一个二叉堆。

    我们同样以上面的数组为例，假设其数组内元素的原始顺序为：A[]={6,1,3,9,5,4,2,7}，那么在没有建成二叉堆前，个元素在该完全二叉树中的存放位置如下：


    这里的后面四个元素均为叶子节点，很明显，这四个叶子可以认为是一个堆（因为堆的定义中并没有对左右孩子间的关系有任何要求，所以可以将这几个叶子节点看做是一个堆），而后我们便考虑将第一个非叶子节点9插入到这个堆中，再次构成一个堆，接着再将3插入到新的堆中，再次构成新堆，如此继续，直到该二叉树的根节点6也插入到了该堆中，此时构成的堆便是由该数组建成的二叉堆。因此，我们这里同样可以利用到上面所写的HeapAdjustDown(int *,int,int)函数，因此建堆的代码可写成如下的形式:

[cpp]  view plain   copy
  1. //把数组建成为最大堆  
  2. //第一个非叶子节点的位置序号为(len-1)/2  
  3. for(i=(len-1)/2;i>=0;i--)  
  4.     HeapAdjustDown(arr,i,len-1);  

    如果还不是很明白，注意读下HeapAdjustDown(int *,int,int)函数代码中关于该函数作用的注释。

完整源码

    最后贴出完整源码：

[cpp]  view plain   copy
  1. /******************************* 
  2.             堆排序 
  3. Author:兰亭风雨 Date:2014-02-27 
  4. Email:[email protected] 
  5. ********************************/  
  6. #include<stdio.h>  
  7. #include<stdlib.h>  
  8.   
  9. /* 
  10. arr[start+1...end]满足最大堆的定义， 
  11. 将arr[start]加入到最大堆arr[start+1...end]中， 
  12. 调整arr[start]的位置，使arr[start...end]也成为最大堆 
  13. 注：由于数组从0开始计算序号，也就是二叉堆的根节点序号为0， 
  14. 因此序号为i的左右子节点的序号分别为2i+1和2i+2 
  15. */  
  16. void HeapAdjustDown(int *arr,int start,int end)  
  17. {  
  18.     int temp = arr[start];  //保存当前节点  
  19.     int i = 2*start+1;      //该节点的左孩子在数组中的位置序号  
  20.     while(i<=end)  
  21.     {  
  22.         //找出左右孩子中最大的那个  
  23.         if(i+1<=end && arr[i+1]>arr[i])    
  24.             i++;  
  25.         //如果符合堆的定义，则不用调整位置  
  26.         if(arr[i]<=temp)   
  27.             break;  
  28.         //最大的子节点向上移动，替换掉其父节点  
  29.         arr[start] = arr[i];  
  30.         start = i;  
  31.         i = 2*start+1;  
  32.     }  
  33.     arr[start] = temp;  
  34. }  
  35.   
  36. /* 
  37. 堆排序后的顺序为从小到大 
  38. 因此需要建立最大堆 
  39. */  
  40. void Heap_Sort(int *arr,int len)  
  41. {  
  42.     int i;  
  43.     //把数组建成为最大堆  
  44.     //第一个非叶子节点的位置序号为len/2-1  
  45.     for(i=len/2-1;i>=0;i--)  
  46.         HeapAdjustDown(arr,i,len-1);  
  47.     //进行堆排序  
  48.     for(i=len-1;i>0;i--)  
  49.     {  
  50.         //堆顶元素和最后一个元素交换位置，  
  51.         //这样最后的一个位置保存的是最大的数，  
  52.         //每次循环依次将次大的数值在放进其前面一个位置，  
  53.         //这样得到的顺序就是从小到大  
  54.         int temp = arr[i];  
  55.         arr[i] = arr[0];  
  56.         arr[0] = temp;  
  57.         //将arr[0...i-1]重新调整为最大堆  
  58.         HeapAdjustDown(arr,0,i-1);  
  59.     }  
  60. }  
  61.   
  62. int main()  
  63. {  
  64.     int num;  
  65.     printf("请输入排序的元素的个数：");  
  66.     scanf("%d",&num);  
  67.   
  68.     int i;  
  69.     int *arr = (int *)malloc(num*sizeof(int));  
  70.     printf("请依次输入这%d个元素（必须为整数）：",num);  
  71.     for(i=0;i<num;i++)  
  72.         scanf("%d",arr+i);  
  73.   
  74.     printf("堆排序后的顺序：");  
  75.     Heap_Sort(arr,num);  
  76.     for(i=0;i<num;i++)  
  77.         printf("%d ",arr[i]);  
  78.     printf("\n");  
  79.   
  80.     free(arr);  
  81.     arr = 0;  
  82.     return 0;  
  83. }  
    测试结果如下：


总结

    最后我们简要分析下堆排序的时间复杂度。我们在每次重新调整堆时，都要将父节点与孩子节点比较，这样，每次重新调整堆的时间复杂度变为O（logn），而堆排序时有n-1次重新调整堆的操作，建堆时有（（len-1）/2+1）次重新调整堆的操作，因此堆排序的平均时间复杂度为O（n*logn）。由于我们这里没有借用辅助存储空间，因此空间复杂度为O（1）。

    堆排序在排序元素较少时有点大才小用，待排序列元素较多时，堆排序还是很有效的。另外，堆排序在最坏情况下，时间复杂度也为O（n*logn）。相对于快速排序（平均时间复杂度为O（n*logn），最坏情况下为O（n*n）），这是堆排序的最大优点。
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33348709/article/details/78005278

智能推荐

攻防世界_难度8_happy_puzzle_攻防世界困难模式攻略图文-程序员宅基地

文章浏览阅读645次。这个肯定是末尾的IDAT了，因为IDAT必须要满了才会开始一下个IDAT，这个明显就是末尾的IDAT了。，对应下面的create_head()代码。，对应下面的create_tail()代码。不要考虑爆破，我已经试了一下，太多情况了。题目来源：UNCTF。_攻防世界困难模式攻略图文

达梦数据库的导出（备份）、导入_达梦数据库导入导出-程序员宅基地

文章浏览阅读2.9k次，点赞3次，收藏10次。偶尔会用到，记录、分享。1. 数据库导出1.1 切换到dmdba用户su - dmdba1.2 进入达梦数据库安装路径的bin目录，执行导库操作　　导出语句：./dexp cwy_init/[email protected]:5236 file=cwy_init.dmp log=cwy_init_exp.log　注释：　　 cwy_init/init_123..._达梦数据库导入导出

js引入kindeditor富文本编辑器的使用_kindeditor.js-程序员宅基地

文章浏览阅读1.9k次。1. 在官网上下载KindEditor文件，可以删掉不需要要到的jsp，asp，asp.net和php文件夹。接着把文件夹放到项目文件目录下。2. 修改html文件，在页面引入js文件：<script type="text/javascript" src="./kindeditor/kindeditor-all.js"></script><script type="text/javascript" src="./kindeditor/lang/zh-CN.js"_kindeditor.js

STM32学习过程记录11——基于STM32G431CBU6硬件SPI+DMA的高效WS2812B控制方法-程序员宅基地

文章浏览阅读2.3k次，点赞6次，收藏14次。SPI的详情简介不必赘述。假设我们通过SPI发送0xAA，我们的数据线就会变为10101010，通过修改不同的内容，即可修改SPI中0和1的持续时间。比如0xF0即为前半周期为高电平，后半周期为低电平的状态。在SPI的通信模式中，CPHA配置会影响该实验，下图展示了不同采样位置的SPI时序图[1]。CPOL = 0，CPHA = 1：CLK空闲状态 = 低电平，数据在下降沿采样，并在上升沿移出CPOL = 0，CPHA = 0：CLK空闲状态 = 低电平，数据在上升沿采样，并在下降沿移出。_stm32g431cbu6

计算机网络-数据链路层_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输-程序员宅基地

文章浏览阅读1.2k次，点赞2次，收藏8次。数据链路层习题自测问题1.数据链路(即逻辑链路)与链路(即物理链路)有何区别?“电路接通了”与”数据链路接通了”的区别何在?2.数据链路层中的链路控制包括哪些功能?试讨论数据链路层做成可靠的链路层有哪些优点和缺点。3.网络适配器的作用是什么?网络适配器工作在哪一层?4.数据链路层的三个基本问题(帧定界、透明传输和差错检测)为什么都必须加以解决？5.如果在数据链路层不进行帧定界，会发生什么问题？6.PPP协议的主要特点是什么？为什么PPP不使用帧的编号？PPP适用于什么情况？为什么PPP协议不_接收方收到链路层数据后,使用crc检验后,余数为0,说明链路层的传输时可靠传输

软件测试工程师移民加拿大_无证移民，未受过软件工程师的教育（第1部分）-程序员宅基地

文章浏览阅读587次。软件测试工程师移民加拿大 无证移民，未受过软件工程师的教育(第1部分) (Undocumented Immigrant With No Education to Software Engineer(Part 1))Before I start, I want you to please bear with me on the way I write, I have very little gen...

随便推点

Thinkpad X250 secure boot failed 启动失败问题解决_安装完系统提示secureboot failure-程序员宅基地

文章浏览阅读304次。Thinkpad X250笔记本电脑，装的是FreeBSD，进入BIOS修改虚拟化配置（其后可能是误设置了安全开机），保存退出后系统无法启动，显示：secure boot failed ，把自己惊出一身冷汗，因为这台笔记本刚好还没开始做备份.....根据错误提示，到bios里面去找相关配置，在Security里面找到了Secure Boot选项，发现果然被设置为Enabled，将其修改为Disabled ，再开机，终于正常启动了。_安装完系统提示secureboot failure

C++如何做字符串分割（5种方法）_c++ 字符串分割-程序员宅基地

文章浏览阅读10w+次，点赞93次，收藏352次。1、用strtok函数进行字符串分割原型： char *strtok(char *str, const char *delim);功能：分解字符串为一组字符串。参数说明：str为要分解的字符串，delim为分隔符字符串。返回值：从str开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。其它：strtok函数线程不安全，可以使用strtok_r替代。示例：//借助strtok实现split#include <string.h>#include <stdio.h&_c++ 字符串分割

2013第四届蓝桥杯 C/C++本科A组 真题答案解析_2013年第四届c a组蓝桥杯省赛真题解答-程序员宅基地

文章浏览阅读2.3k次。1 .高斯日记 大数学家高斯有个好习惯：无论如何都要记日记。他的日记有个与众不同的地方，他从不注明年月日，而是用一个整数代替，比如：4210后来人们知道，那个整数就是日期，它表示那一天是高斯出生后的第几天。这或许也是个好习惯，它时时刻刻提醒着主人：日子又过去一天，还有多少时光可以用于浪费呢？高斯出生于：1777年4月30日。在高斯发现的一个重要定理的日记_2013年第四届c a组蓝桥杯省赛真题解答

基于供需算法优化的核极限学习机(KELM)分类算法-程序员宅基地

文章浏览阅读851次，点赞17次，收藏22次。摘要：本文利用供需算法对核极限学习机(KELM)进行优化，并用于分类。

metasploitable2渗透测试_metasploitable2怎么进入-程序员宅基地

文章浏览阅读1.1k次。一、系统弱密码登录1、在kali上执行命令行telnet 192.168.26.1292、Login和password都输入msfadmin3、登录成功，进入系统4、测试如下：二、MySQL弱密码登录：1、在kali上执行mysql –h 192.168.26.129 –u root2、登录成功，进入MySQL系统3、测试效果：三、PostgreSQL弱密码登录1、在Kali上执行psql -h 192.168.26.129 –U post..._metasploitable2怎么进入

Python学习之路：从入门到精通的指南_python人工智能开发从入门到精通pdf-程序员宅基地

文章浏览阅读257次。本文将为初学者提供Python学习的详细指南，从Python的历史、基础语法和数据类型到面向对象编程、模块和库的使用。通过本文，您将能够掌握Python编程的核心概念，为今后的编程学习和实践打下坚实基础。_python人工智能开发从入门到精通pdf

推荐文章

热门文章

相关标签