神刀安全网

堆排序

前言

堆排序在面试中是经常会问到的,特别是应届毕业生找工作时,面试官最喜欢问这个了。当年百度二面的时候,也被这个算法给刷了,因为像我这种不入流的大学,平时所学习的算法只是讲讲基本原理,却没有真正要求动手去实现,因此到真正需要应用的时候,根本就不懂如何去应用。

今天,在回忆、学习完堆排序的相关知识后,希望通过写下本篇文章,将所有的理论知识使用笔者的语言来表达出来,希望能够让大家更容易理解和吸收。

基础知识

我们通常所说的堆是指二叉堆,二叉堆又称完全二叉树或者叫近似完全二叉树。二叉堆又分为最大堆和最小堆。

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法,它是 选择排序 的一种。可以利用数组的特点快速定位指定索引的元素。数组可以根据索引直接获取元素,时间复杂度为O(1),也就是常量,因此对于取值效率极高。

最大堆的特性如下:

  • 父结点的键值总是大于或者等于任何一个子节点的键值
  • 每个结点的左子树和右子树都是一个最大堆

最小堆的特性如下:

  • 父结点的键值总是小于或者等于任何一个子节点的键值
  • 每个结点的左子树和右子树都是一个最小堆

算法思想

最大堆的算法思想是:

  • 先将初始的R[0…n-1]建立成最大堆,此时是 无序 堆,而堆顶是最大元素
  • 再将堆顶R[0]和无序区的最后一个记录R[n-1]交换,由此得到新的无序区R[0…n-2]和有序区R[n-1],且满足R[0…n-2].keys ≤ R[n-1].key
  • 由于交换后,前R[0…n-2]可能不满足最大堆的性质,因此再调整前R[0…n-2]为最大堆,直到只有R[0]最后一个元素才调整完成。

最大堆排序完成后,其实是升序序列,每次调整堆都是要得到最大的一个元素,然后与当前堆的最后一个元素交换,因此最后所得到的序列是升序序列。

最小堆的算法思想是:

  • 先将初始的R[0…n-1]建立成最小堆,此时是 无序 堆,而堆顶元素是最大的元素
  • 再将堆顶R[0]与无序区的最后一个R[n-1]交换,由此得到新的无序堆R[0…n-2]和有序堆R[n-1],且满足R[0…n-2].keys <= R[n-1].key
  • 由于交换后,前R[0…n-2]可能不满足最小堆的性质,因此再调整前R[0…n-2]为最小堆,直到只有R[0]最后一个元素才调整完成

最小堆排序完成后,其实是降序序列,每次调整堆都是要得到最小的一个元素,然后与当前无序堆的最后一个元素交换,所以所得到的序列是降序的。

提示:堆排序的过程,其实就是不断地扩大有序区,然后不断地缩小无序区,直到只有有序区的过程。

排序过程分析

因为算法比较抽象,这里直接通过举个小例子来说明堆排序的过程是如何的。下面我们用这个无序序列采用最大堆的进行堆排序,所得到的序列就是升序序列(ASC)。

无序序列:89,-7,999,-89,7,0,-888,7,-7

第一步:初始化建成最大堆:

堆排序

第二步:将堆顶最大元素999与无序区的最后一个元素交换,使999成为有序区。交换后,-7成为堆顶,由于-7并不是无序区中最大的元素,因此需要调整无序区,使无序区中最大值89成为堆顶,所以-7与89交换。交换后导致89的右子树不满足最大堆的性质,因此要对右子树调整成最大堆,所以-7要与0交换,如下图:

堆排序

从图中看到,当-7成89交换后,堆顶是最大元素了,但是-7的左孩子是0,右孩子是-888,由于-7<0,导致-7这个结点不满足堆的性质,因此需要调整它。所以,0与-7交换。

然后不断重复着第二步的过程,直到全部成为有序区。

最后:所得到的是升序序列

堆排序

时间复杂度

堆排序的时间,主要由建立初始堆和反复调整堆这两部分的时间开销构成.由于堆排序是不稳定的,它得扭到的时间复杂度会根据实际情况较大,因此只能取平均时间复杂度。

平均时间复杂度为:O( N * log 2 (N) )

堆排序耗时的操作有:初始堆 + 反复调整堆,时间复杂度如下:

  • 初始建堆:每个父节点会和左右子节点进行最多2次比较和1次交换,所以复杂度跟父节点个数有关。根据2 x <= n(x为n个元素可以折半的次数,也就是父节点个数),得出x = log 2 n。即O ( log 2 n )
  • 反复调整堆:由于初始化堆过程中,会记录数组比较结果,所以堆排序对原序列的数组顺序并不敏感,最好情况和最坏情况差不多。需要抽取 n-1 次堆顶元素,每次取堆顶元素都需要重建堆(O(重建堆) < O(初始堆))。所以小于 O(n-1) * O(log 2 n)

使用建议:

由于初始化堆需要比较的次数较多,因此,堆排序比较适合于数据量非常大的场合(百万数据或更多)。由于高效的快速排序是基于递归实现的,所以在数据量非常大时会发生堆栈溢出错误。

C语言实现

基于最大堆实现升序排序

  // 初始化堆 void initHeap(int a[], int len) {   // 从完全二叉树最后一个非子节点开始   // 在数组中第一个元素的索引是0   // 第n个元素的左孩子为2n+1,右孩子为2n+2,   // 最后一个非子节点位置在(n - 1) / 2   for (int i = (len - 1) / 2; i >= 0; --i) {     adjustMaxHeap(a, len, i);   } }   void adjustMaxHeap(int a[], int len, int parentNodeIndex) {   // 若只有一个元素,那么只能是堆顶元素,也没有必要再排序了   if (len <= 1) {     return;   }     // 记录比父节点大的左孩子或者右孩子的索引   int targetIndex = -1;      // 获取左、右孩子的索引   int leftChildIndex = 2 * parentNodeIndex + 1;   int rightChildIndex = 2 * parentNodeIndex + 2;     // 没有左孩子   if (leftChildIndex >= len) {     return;   }      // 有左孩子,但是没有右孩子   if (rightChildIndex >= len) {     targetIndex = leftChildIndex;   }   // 有左孩子和右孩子   else {     // 取左、右孩子两者中最大的一个     targetIndex = a[leftChildIndex] > a[rightChildIndex] ?leftChildIndex: rightChildIndex;   }      // 只有孩子比父节点的值还要大,才需要交换   if (a[targetIndex] > a[parentNodeIndex]) {     int temp = a[targetIndex];          a[targetIndex] = a[parentNodeIndex];     a[parentNodeIndex] = temp;               // 交换完成后,有可能会导致a[targetIndex]结点所形成的子树不满足堆的条件,     // 若不满足堆的条件,则调整之使之也成为堆     adjustMaxHeap(a, len, targetIndex);   } }   void heapSort(int a[], int len) {   if (len <= 1) {     return;   }      // 初始堆成无序最大堆   initHeap(a, len);      for (int i = len - 1; i > 0; --i) {     // 将当前堆顶元素与最后一个元素交换,保证这一趟所查找到的堆顶元素与最后一个元素交换     // 注意:这里所说的最后不是a[len - 1],而是每一趟的范围中最后一个元素     // 为什么要加上>0判断?每次不是说堆顶一定是最大值吗?没错,每一趟调整后,堆顶是最大值的     // 但是,由于len的范围不断地缩小,导致某些特殊的序列出现异常     // 比如说,5, 3, 8, 6, 4序列,当调整i=1时,已经调整为3,4,5,6,8序列,已经有序了     // 但是导致了a[i]与a[0]交换,由于变成了4,3,5,6,8反而变成无序了!     if (a[0] > a[i]) {       int temp = a[0];       a[0] = a[i];       a[i] = temp;     }          // 范围变成为:     // 0...len-1     // 0...len-1-1     // 0...1 // 结束     // 其中,0是堆顶,每次都是找出在指定的范围内比堆顶还大的元素,然后与堆顶元素交换     adjustMaxHeap(a, i - 1, 0);   } }   

基于最小堆实现降序排序

  // 初始化堆 void initHeap(int a[], int len) {   // 从完全二叉树最后一个非子节点开始   // 在数组中第一个元素的索引是0   // 第n个元素的左孩子为2n+1,右孩子为2n+2,   // 最后一个非子节点位置在(n - 1) / 2   for (int i = (len - 1) / 2; i >= 0; --i) {     adjustMaxHeap(a, len, i);   } }   void adjustMaxHeap(int a[], int len, int parentNodeIndex) {   // 若只有一个元素,那么只能是堆顶元素,也没有必要再排序了   if (len <= 1) {     return;   }      // 记录比父节点大的左孩子或者右孩子的索引   int targetIndex = -1;      // 获取左、右孩子的索引   int leftChildIndex = 2 * parentNodeIndex + 1;   int rightChildIndex = 2 * parentNodeIndex + 2;      // 没有左孩子   if (leftChildIndex >= len) {     return;   }      // 有左孩子,但是没有右孩子   if (rightChildIndex >= len) {     targetIndex = leftChildIndex;   }   // 有左孩子和右孩子   else {     // 取左、右孩子两者中最上的一个     targetIndex = a[leftChildIndex] < a[rightChildIndex] ?leftChildIndex: rightChildIndex;   }      // 只有孩子比父节点的值还要小,才需要交换   if (a[targetIndex] < a[parentNodeIndex]) {     int temp = a[targetIndex];          a[targetIndex] = a[parentNodeIndex];     a[parentNodeIndex] = temp;               // 交换完成后,有可能会导致a[targetIndex]结点所形成的子树不满足堆的条件,     // 若不满足堆的条件,则调整之使之也成为堆     adjustMaxHeap(a, len, targetIndex);   } }   void heapSort(int a[], int len) {   if (len <= 1) {     return;   }      // 初始堆成无序最小堆   initHeap(a, len);      for (int i = len - 1; i > 0; --i) {     // 将当前堆顶元素与最后一个元素交换,保证这一趟所查找到的堆顶元素与最后一个元素交换     // 注意:这里所说的最后不是a[len - 1],而是每一趟的范围中最后一个元素     // 为什么要加上>0判断?每次不是说堆顶一定是最小值吗?没错,每一趟调整后,堆顶是最小值的     // 但是,由于len的范围不断地缩小,导致某些特殊的序列出现异常     // 比如说,5, 3, 8, 6, 4序列,当调整i=1时,已经调整为3,4,5,6,8序列,已经有序了     // 但是导致了a[i]与a[0]交换,由于变成了4,3,5,6,8反而变成无序了!     if (a[0] < a[i]) {       int temp = a[0];       a[0] = a[i];       a[i] = temp;     }          // 范围变成为:     // 0...len-1     // 0...len-1-1     // 0...1 // 结束     // 其中,0是堆顶,每次都是找出在指定的范围内比堆顶还小的元素,然后与堆顶元素交换     adjustMaxHeap(a, i - 1, 0);   } }   

C语言版测试

大家可以测试一下:

  //  int a[] = {5, 3, 8, 6, 4}; int a[] = {89,-7,999,-89,7,0,-888,7,-7}; heapSort(a, sizeof(a) / sizeof(int));   for (int i = 0; i < sizeof(a) / sizeof(int); ++i) {     NSLog(@"%d", a[i]); }   

Swift版实现

基于最大堆实现升序排序

  funcinitHeap(inouta: [Int]) {   forvar i = (a.count - 1) / 2; i >= 0; --i {     adjustMaxHeap(&a,len: a.count,parentNodeIndex: i)   } }   funcadjustMaxHeap(inouta: [Int],len: Int,parentNodeIndex: Int) {   // 如果len <= 0,说明已经无序区已经缩小到0   guardlen > 1 else {     return   }      // 父结点的左、右孩子的索引   letleftChildIndex = 2 * parentNodeIndex + 1      // 如果连左孩子都没有, 一定没有右孩子,说明已经不用再往下了   guardleftChildIndex < lenelse {     return   }      letrightChildIndex = 2 * parentNodeIndex + 2      // 用于记录需要与父结点交换的孩子的索引   vartargetIndex = -1      // 若没有右孩子,但有左孩子,只能选择左孩子   if rightChildIndex > len {     targetIndex = leftChildIndex   } else {     // 左、右孩子都有,则需要找出最大的一个     targetIndex = a[leftChildIndex] > a[rightChildIndex] ?leftChildIndex: rightChildIndex   }      // 只有孩子比父结点还要大,再需要交换   if a[targetIndex] > a[parentNodeIndex] {     lettemp = a[targetIndex]          a[targetIndex] = a[parentNodeIndex]     a[parentNodeIndex] = temp          // 由于交换后,可能会破坏掉新的子树堆的性质,因此需要调整以a[targetIndex]为父结点的子树,使之满足堆的性质     adjustMaxHeap(&a,len: len,parentNodeIndex: targetIndex)   } }   funcmaxHeapSort(inouta: [Int]) {   guard a.count > 1 else {     return   }      initHeap(&a)      forvar i = a.count - 1; i > 0; --i {     // 每一趟都将堆顶交换到指定范围内的最后一个位置     if a[0] > a[i] {       lettemp = a[0]              a[0] = a[i]       a[i] = temp     }     print(a)     print(i - 1)     // 有序区长度+1,而无序区长度-1,继续缩小无序区,所以i-1     // 堆顶永远是在0号位置,所以父结点调整从堆顶开始就可以了     adjustMaxHeap(&a, len: i - 1, parentNodeIndex: 0)     print(a)   } }   

基于最小堆降序排序

  funcinitHeap(inouta: [Int]) {   forvar i = (a.count - 1) / 2; i >= 0; --i {     adjustMaxHeap(&a,len: a.count,parentNodeIndex: i)   } }   funcadjustMaxHeap(inouta: [Int],len: Int,parentNodeIndex: Int) {   // 如果len <= 0,说明已经无序区已经缩小到0   guardlen > 1 else {     return   }      // 父结点的左、右孩子的索引   letleftChildIndex = 2 * parentNodeIndex + 1      // 如果连左孩子都没有, 一定没有右孩子,说明已经不用再往下了   guardleftChildIndex < lenelse {     return   }      letrightChildIndex = 2 * parentNodeIndex + 2      // 用于记录需要与父结点交换的孩子的索引   vartargetIndex = -1      // 若没有右孩子,但有左孩子,只能选择左孩子   if rightChildIndex > len {     targetIndex = leftChildIndex   } else {     // 左、右孩子都有,则需要找出最大的一个     targetIndex = a[leftChildIndex] < a[rightChildIndex] ?leftChildIndex: rightChildIndex   }      // 只有孩子比父结点还要大,再需要交换   if a[targetIndex] < a[parentNodeIndex] {     lettemp = a[targetIndex]          a[targetIndex] = a[parentNodeIndex]     a[parentNodeIndex] = temp          // 由于交换后,可能会破坏掉新的子树堆的性质,因此需要调整以a[targetIndex]为父结点的子树,使之满足堆的性质     adjustMaxHeap(&a,len: len,parentNodeIndex: targetIndex)   } }   funcmaxHeapSort(inouta: [Int]) {   guard a.count > 1 else {     return   }      initHeap(&a)      forvar i = a.count - 1; i > 0; --i {     // 每一趟都将堆顶交换到指定范围内的最后一个位置     if a[0] < a[i] {       lettemp = a[0]              a[0] = a[i]       a[i] = temp     } else {       return // 可以直接退出了,因为已经全部有序了     }     print(a)     print(i - 1)     // 有序区长度+1,而无序区长度-1,继续缩小无序区,所以i-1     // 堆顶永远是在0号位置,所以父结点调整从堆顶开始就可以了     adjustMaxHeap(&a, len: i - 1, parentNodeIndex: 0)     print(a)   } }   

测试:

  vararr = [5, 3, 8, 6, 4] //var arr = [89,-7,999,-89,7,0,-888,7,-7] maxHeapSort(&arr)   print(arr)   // 打印日志如下: [4, 6, 5, 3, 8] 3 [6, 4, 5, 3, 8]   [3, 4, 5, 6, 8] 2 [5, 4, 3, 6, 8]   [3, 4, 5, 6, 8] 1 [3, 4, 5, 6, 8]   [3, 4, 5, 6, 8] 0 [3, 4, 5, 6, 8]   [3, 4, 5, 6, 8]   

最后

花了将近一天半的时间来整理这篇文章,同时深入地理解这个算法。这个过程中,查了很多篇博客讲解堆排序的,但是都是很难去理解,而且所提供的代码都是有一定问题的。经过这么一折腾,终于把堆排序给理明白了。如果大家在学习时遇到问题,再联系笔者吧!

关注我

关注 账号 备注
标哥博客iOS交流群一 324400294(满) 群一若已满,请申请群二
标哥博客iOS交流群二 494669518(满) 群二若已满,请申请群三
标哥博客iOS交流群三 461252383(满) 群三若已满,请申请群四
标哥博客iOS交流群四 250351140 群四若已满,会有提示信息
关注微信公众号 iOSDevShares 关注微信公众号,会定期地推送好文章
关注新浪微博账号 标哥的技术博客 关注微博,每次发布文章都会分享到新浪微博
关注标哥的GitHub CoderJackyHuang 这里有很多的Demo和开源组件
关于我 进一步了解标哥 如果觉得文章对您很有帮助,可捐助我!

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » 堆排序

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮