【数据结构与算法】内部排序之三:堆排序(含完整源码)


转载请注明出处: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:zyb_maodun@163.com 
  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)),这是堆排序的最大优点。



本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/383910.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

模线性方程(中国剩余定理+扩展中国剩余定理)

已知一系列除数和模数,求最小的满足条件的数 我们先考虑一般的情况&#xff0c;即模数不互质。&#xff08;扩展中国剩余定理&#xff09; 我们考虑两个方程的情况 x%MR xk1∗MRxk1 * MRxk1∗MR x%mr xk2∗mrxk2 * mrxk2∗mr 所以k1∗MRk2∗mrk1 * MRk2 * mrk1∗MRk2∗mr 即…

C++:Vector和List的实现

Vector的实现 //test.h #pragma once#include <iostream> #include <cstdio> #include <string.h> #include <assert.h>using namespace std;typedef int DataType;#define TESTHEADER printf("\n%s\n", __FUNCTION__)class Vector { publi…

【数据结构】(面试题)使用两个栈实现一个队列(详细介绍)

http://blog.csdn.net/hanjing_1995/article/details/51539578 使用两个栈实现一个队列 思路一&#xff1a; 我们设定s1是入栈的&#xff0c;s2是出栈的。 入队列&#xff0c;直接压到s1即可 出队列&#xff0c;先把s1中的元素倒入到s2中&#xff0c;弹出s2中的栈顶元素&#x…

POJ 1006 Biorhythms

中国剩余定理的模板题 只是有一个问题就是求出来Xk*MR中的R比给定的日期还大&#xff0c;但是如果负数的整除就不是向下取整了&#xff0c;为了解决这个问题&#xff0c;我们将R减小M&#xff0c;这样总是正的&#xff0c;求出来的就没有什么问题。 #include <iostream>…

POJ 3696 欧拉函数+快速幂

题目的意思大概就是问是否存在一串全是8的数字是L的倍数 直接想没有什么想法&#xff0c;要想到用简洁的形式将这个数字表示出来&#xff0c;对于每一位都是8的数字我们可以用 X8*(10k-1)/9的形式表示出来&#xff0c;那么题目的意思就是求X使L|X&#xff0c;我们先处理一下8和…

两个栈实现一个队列,两个队列实现一个栈

http://blog.csdn.net/zw_1510/article/details/51927554 问题1&#xff1a;用两个栈实现一个队列&#xff0c;实现队列的push和delete操作 栈的特性是先进后出&#xff08;FILO&#xff09;,队列的特性是先进先出&#xff08;FIFO&#xff09;,在实现delete时&#xff0c;我们…

C++:String的写时拷贝

String的写时拷贝 //test.h #pragma once#include <iostream> #include <string.h> #include <cstdio> #include <assert.h> using namespace std;#define TESTHEADER printf("\n%s\n", __FUNCTION__) class String { public:String(const …

两个栈实现一个队列与两个队列实现一个栈

http://blog.csdn.net/z84616995z/article/details/19204529 两个栈实现一个队列&#xff1a; 原理方法&#xff1a;用一个栈为主栈&#xff0c;一个栈为辅助栈存放临时元素。 入队&#xff1a;将元素依次压入主栈 出队&#xff1a;先检测辅助栈是否为空&#xff0c;如果非空&a…

UVa11426——欧拉函数

发现对于gcd问题要多和欧拉函数联系在一起&#xff0c;虽然有时候并不是互质&#xff0c;但是我们知道有多少互质的然后根据互质的数目就能解决很多个gcd的问题 对于这道题目&#xff0c;题目要求的是所有数对的gcd的和&#xff0c;直接思考的话有难度。但是我们如果联想到欧拉…

C++:继承和多态

虚函数:只有类的成员函数才能定义为虚函数 虚函数 在类的成员函数前面加上一个 virtual 关键字, 此时这个成员函数就叫做虚函数 虚函数 当在子类中定义了一个与父类完全相同的虚函数的时候,此时就叫做子类的虚函数重写了父类的虚函数 构成多态的条件 派生类重写基类的虚函数…

POJ 1061扩展欧几里得

扩展欧几里得的模板题&#xff0c;需要注意的是为了得到一个最小正数解我们要使axbyc中的a,b都是正数 #include<cstdio> #include<cstring> #include<cstdlib> #include<algorithm> #include<iostream> #include<cmath> #include<ctim…

C++::探索对象模型

前面我们已经知道, 在没有虚函数的时候, 对象的大小就是对应的成员变量的大小, 而成员函数不会占用对象的空间, 今天我们来讨论一下, 当类中定义了虚函数的时候, 此时对象的大小以及对象模型 非继承下的对象模型 class Base { public:virtual void func1(){cout << &qu…

auto_ptr

#include <iostream> #include <memory> using namespace std;class A { public:A(){cout<<"构造"<<endl;}~A(){cout<<"A析构"<<endl;}void fun(){cout<<"A::fun"<<endl;} };class PA { public…

POJ 2142——扩展欧几里得

题目是很裸的扩展欧几里得&#xff0c;但是对x,y有限制条件&#xff0c;要求所有x,y中abs(x)abs(y)最小&#xff0c;在这个条件下要求abs(a* x)abs(b* y)最小 显然我们需要用扩展欧几里得求得一组解&#xff0c;问题在于如何处理这组解以得到符合条件的值。 我是这样处理的&a…

C++::模板

模板的简单介绍 C中模板是为了能够使得函数或者类实现范型编程的目的, 同时C模板的出现是为了避免代码的冗余 举个例子 void Swap(int& a, int& b) {int tmp a;b a;a b; } void Swap(char& a, char& b) {char tmp a;b a;a b; } 上面的函数除了类型不…

Linux select TCP并发服务器与客户端编程

http://blog.csdn.net/szkbsgy/article/details/10558881 [cpp] view plaincopy <span style"font-size:18px;">服务端&#xff1a; #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/time.h> #i…

BZOJ - 2186 欧拉函数

题目的意思大概是求1~N!中和M&#xff01;互质的数的个数 因为对欧拉函数理解不够深刻所以我是分析得到结果的&#xff1a; 当N<M的时候显然符合要求的数的个数为0&#xff1b; 当N>M的时候我们要求的是1~N!中不含1 ~M的素因子的的数的个数&#xff0c;结合欧拉函数的…

多态相关概念

多态相关注意事项 所谓的多态就是指函数有多中状态, 在C中通常是通过父类指针指向子类对象的方法实现多态, 这样父类可以通过子类的类型调用不同的方法. 即实现一个接口多种方法, 多态的引用是为了实现接口复用 在 C中多态是通过虚函数来实现的. 子类通过对父类相关接口进行重…

模板实现栈队列以及链表

模板实现链表 //test.h #include <iostream> #include <cstdio> #include <assert.h> using namespace std;template <class T> struct ListNode {ListNode* _prev;ListNode* _next;T _data;ListNode(const T& x):_prev(NULL),_next(NULL),_data(…

基于Visual C++2013拆解世界五百强面试题--题5-自己实现strstr

http://blog.csdn.net/itcastcpp/article/details/12907371 请用C语言实现字符串的查找函数strstr&#xff0c; 找到则返回子字符串的地址&#xff0c;没有找到返回为空&#xff0c;请用数组操作与指针操作实现 看到题目想到最简单的方法就是母字符串和子字符串比较&#xff0c…