数据结构与算法-堆排序

小灰灰 2022-04-04 12:54 209阅读 0赞

### 概要 ###

*   *   *  简单选择排序的改进
         *  堆的基本概念
         *  堆排序的基本思想
         *  java代码实现
         *  图示执行过程
         *  时间复杂度分析

### 简单选择排序的改进 ###

> [简单选择排序][Link 1]，它在待排序的n-i个记录中选择一个最小的记录需要比较n-i次(1≤i≤n-1)，查找第一个数据需要比较这么多次是正常的，否则如何知道它是最小的记录。可惜的是，这样的操作并没有把每一趟的比较记录保存下来，在后一趟的比较中，有许多比较在前一趟已经做过了，但由于前一趟排序时未保存这些比较结果，所以后一趟排序时又重复执行了这些比较操作，因而记录的比较次数较多。  
> 如果可以做到每次在选择到最小记录的同时，并根据比较结果对其他记录做出相应的调整，那样排序的总体效率就会非常高了。而堆排序就是对简单选择排序进行的这样一种改进。

### 堆的基本概念 ###

> 堆是具有下列性质的完全二叉树：每个结点的值都大于或者等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。简言之，堆是一棵顺序存储的完全二叉树。如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70][]

### 堆排序的基本思想 ###

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

### java代码实现 ###

/**
     * 构造大顶堆函数
     * @param a 	 待排序列
     * @param parent 非终端结点
     * @param length 结点总数
     */
    void heapAdjust(int[] a, int parent, int length) {
        
         int temp = a[parent]; /* 保存非终端结点即父节点的值 */
         int child = 2*parent+1; /* 左孩(待排序列下标从0算起) */
         while (child < length) {
         /* 判断当前非终端结点是否有左孩 */
         	if (child+1 < length && a[child] < a[child+1]) {
         /* 当前非终端结点有右孩且右孩比左孩大，则选取右孩结点 */
         	    child++;
         	}
         	if (temp >= a[child]) {
         /* 如果父节点大于孩子结点，则直接结束 */
         	    break;
         	}
         	a[parent] = a[child]; /* 孩子结点值赋值给父节点 */
         	/* 将当前选中的孩子结点作为临时父节点，继续向下筛选 */
         	parent = child;
         	child = 2*parent+1;
         }
         a[parent] = temp; /* 将之前父节点的值赋值给当前选中的结点(临时父节点) */
    }
    
    /**
     * 堆排序函数
     * @param a 待排序列
     */
    void heapSort(int[] a) {
        
         /* 将初始无序待排列构造成大顶堆 */
         for (int i = a.length/2-1; i >= 0; i--) {
         /* 根据二叉树性质，i从【n/2向下取整】开始遍历，这边-1是因为我们从下标0开始算起 */
         	 heapAdjust(a, i, a.length); 
         }
         
         /* 首尾记录交换与重新构造堆 */
         for (int j = a.length-1; j > 0; j--) {
        
         	 /* 将堆顶记录和当前未经排序子序列的最后一个记录交换 */
             int temp = a[j];
             a[j] = a[0];
             a[0] = temp;
             /* 将剩余记录重新构造大顶堆 */
             heapAdjust(a, 0, j);
         }
    }
    
    //声明待排序列
    int[] a = {
        9,1,5,8,3,7,4,6,2};
    
    //测试调用
    heapSort(a); //输出1,2,3,4,5,6,7,8,9

### 图示执行过程 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70 2][]

### 时间复杂度分析 ###

*  堆排序运行时间主要是消耗在初始构建堆和在重建堆时的反复筛选上。在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端节点开始构建，将它与其孩子进行比较和若有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个建堆的时间复杂度为0(n)。在正式排序时，第i次取堆顶记录重建堆需要用0(logi)的时间（完全二叉树的某个结点到根结点的距离为log2i+1向下取整）因此，重建堆的时间复杂度为0(nlogn)。
 *  所以总体来说，堆排序的时间复杂度为0(nlogn)。由于堆排序对原始记录的排序状态不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。这在性能上显然要远远好于[冒泡][Link 2]、[简单选择][Link 1]、[直接插入][Link 3]的0(n2)的时间复杂度了。
 *  空间复杂度上，它只有一个用来交换的暂存单元，也非常不错。不过由于记录的比较和交换是跳跃式进行，因此堆排序也是一种不稳定的排序方法。
 *  另外，由于初始构建堆所需的比较次数较多，因此它并不适合待排序序列个数较少的情况。

[Link 1]: https://blog.csdn.net/FTD_SL/article/details/84936838
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70]: /images/20220404/32ff97cb89614b38b08a68a565c17f5b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70 1]: /images/20220404/69fce6be1bba4f15a60816f40c56800c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZURF9TTA_size_16_color_FFFFFF_t_70 2]: /images/20220404/9aa4b6fc1ca041c1a205e66dad7b3bda.png
[Link 2]: https://blog.csdn.net/FTD_SL/article/details/84882498
[Link 3]: https://blog.csdn.net/FTD_SL/article/details/84939505