排序-堆排序

旧城等待， 2022-09-30 06:45 226阅读 0赞

## 1.堆排序前言 ##

前面博客中讲到简单选择排序，它在待排序的n个记录中选择一个最小的记录需要比较n-1次。本来这也可以理解，查找第一个数据需要比较这么多次是正常的，否则如何知道它是最小的记录。可惜的是，这样的操作并没有把每一趟的比较结果保存下来，在后一趟的比较中，有许多比较在前一趟已经做过了，但由于前一趟排序时未保存这些比较结果，所以后一趟排序时又重复执行了这些比较操作，因而记录的比较次数较多。

--------------------

如果可以做到每次在选择到最小记录的同时，并根据比较结果对其他记录做出相应的调整，那样排序的总体效率就会非常高了。而堆排序(Heap Sort)，就是对简单选择排序进行的一种改进，这种改进的效果是非常明显的。堆排序算法是Floyed和Williams在1964年共同发明的，同时，他们发明了“堆”这样的数据结构。

--------------------

## 2.堆排序的定义 ##

> **堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大项堆(最大堆)；或者每个结点的值都小于或等于其左右孩子结点的值，称为小项堆。**

![2lGBqI2.jpg][]

> **堆排序(Heap Sort)就是利用堆(假设利用大堆项)进行排序的方法。它的基本思想是，将待排序的序列构造成一个大项堆。此时，整个序列的最大值就是堆顶的根结点。将它移走(其实就是将其与堆数组的末尾元素交换，此时末尾元素就是最大值)，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复执行，便能得到一个有序序列了。**

相信大家已经明白堆排序的基本思想了，不过要实现还需要解决两个问题：

*  如何由一个无序序列构建成一个堆？
 *  如果在输出堆顶元素后，调整剩余元素成为一个新的堆？

## 3.最大堆的构建过程(最小堆构建原理相同) ##

![W2yC9bl.jpg][]

## 4.堆排序过程图解 ##

![EE1prho.jpg][]

要解释清楚它们，我们来看段C代码。

void HeapSort (SqList *L)
    
    {
    
        int i;
        //把L中的r构建成一个大项堆
        for(i=L->length/2; i>0; i--)
        {
            HeapAdjust(L, i, L->length);
        }
    
        for(i=L->length; i>1; i--)
        {
            //将堆顶记录和当前未经排序子序列的最后一个记录交换
            swap(L, 1, i);
            //将L->r[1..i-1]重新调整为大项堆
            HeapAdjust(L, 1, i-1);
        }

**从代码中也可以看出，整个排序过程分为两个for循环。第一个循环要完成的就是将现在的待排序序列构建成一个大顶堆。第二个循环要完成的就是逐步将每个最大值的根结点与末元素交换，并且再调整其成为大顶堆。**

## 5.堆排序的实现代码(Java) ##

**堆排序类：**

package com.red.sort.heap;
    
    public class HeapSort {
        
    
        public static void heapAdjust(int[] arr, int start, int end) {
    
            int temp = arr[start];//临时变量保存起始值
    
            //修正前是i=2*i，排序的结果不正确
            //经过调试，发现当i=1时，8<=8,会进入第二次循环，会将arr[8]的值赋值给arr[4]=20
            for(int i=2*start+1; i<=end; i=i*2+1) {
                //左右节点的孩子分别为(2*i+1)和(2*i+2)
                //选择出左右孩子较大的下标
                if(i < end && arr[i] < arr[i+1]) {
                    ++i;//现在的i是左右孩子中最大值的下标
                }
                if(temp >= arr[i]){
                    break;//已经为最大堆，退出for循环，保持稳定性
                }
                arr[start] = arr[i];//将子节点上移
                start = i;//下一轮筛选
            }
    
            arr[start] = temp;//插入正确的位置
    
        }
    
        public static void heapSort(int[] arr) {
    
            if(arr == null || arr.length == 0){
                return;
            }
    
            //建立最大堆
            for(int i=arr.length/2; i>=0; i--) {
                heapAdjust(arr, i, arr.length-1);
            }
    
            for(int i=arr.length-1; i>=0; i--) {
                //交换堆顶元素与堆尾元素
                swap(arr, 0, i);
                //建立arr[0...i-1]的最大堆
                heapAdjust(arr, 0, i-1);
            }
    
        }
    
        public static void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    
    }

**测试类：**

package com.red.sort.heap;
    
    public class HeapSortTest {
        
    
        public static void main(String[] args) {
    
            int[] array = new int[]{
       50, 10, 90, 30, 70, 40, 80, 60, 20};
    
            //调用堆排序方法
            HeapSort.heapSort(array);
    
            for(int i=0; i<array.length; i++) {
                System.out.print(array[i] + " ");
            }
    
        }
    
    }

**输出结果：**

10 20 30 40 50 60 70 80 90

## 5.堆排序的复杂度分析 ##

堆排序的运行时间主要是消耗在初始构建堆和重建堆时的反复筛选上。在构件堆的过程中，因为我们是完全二叉树从最下层最右边的非终端结点开始构建，将它与其孩子进行比较和有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互操作，因此这个构件堆的时间复杂度为O(n)。在正式排序时，第i次取堆顶记录重建堆需要用O(logi)的时间(完全二叉树的某个结点到根结点的距离为![dErSLdP.png][]，并且需要n-1次堆顶记录，因此重建堆的时间复杂度为O(nlogn)。所以总体来说，堆排序的时间复杂度为O(nlogn)。由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。这在性能上显然要远远好过于冒泡、简单选择、直接插入的O(n\*n)的时间复杂度了。

空间复杂度上，它只有一个用来交换的存储单元，也非常的不错。不过由于记录的比较与交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。

另外，由于初始构建堆所需的比较次数较多，因此，它并不适合待排序序列个数较少的情况。

[2lGBqI2.jpg]: http://i.imgur.com/2lGBqI2.jpg
[W2yC9bl.jpg]: http://i.imgur.com/W2yC9bl.jpg
[EE1prho.jpg]: http://i.imgur.com/EE1prho.jpg
[dErSLdP.png]: http://i.imgur.com/dErSLdP.png