堆排序

一、堆排序算法介绍

堆是一种数据结构，可以把堆看成一棵完全二叉树，这棵完全二叉树满足：任何一个非叶结点的值都不大于（或不小于）其左右孩子结点的值。若父亲大孩子小，则这样的堆叫做大顶堆；若父亲小孩子大，则这样的堆叫作小顶堆。
堆排序的思想：代表堆的完全二叉树的根结点的值是最大（或最小）的，因此将一个无序序列调整为一个堆，就可以找出这个序列的最大（或最小）值，然后将找出的这个最大值交换到序列的最后（或最前），这样有序序列关键字增加1个，无序序列关键字减少一个，对新的无序序列重复这样的操作，就实现了排序，这就是堆排序的思想。
堆排序中最关键的操作是将序列调整为堆，整个排序的过程就是通过不断调整，使得不符合堆定义的完全二叉树变为符合堆定义的完全二叉树。

二、堆排序执行流程

以大顶堆为例：

1. 从无序序列所确定的完全二叉树的第一个非叶子结点开始，从右至左，从下至上，对每个结点进行调整，最终将得到一个大顶堆。（即第一个元素是”有序“的了！）
   对结点调整的方法：将当前结点（假设为a）的值与其孩子结点进行比较，如果存在大于a值的孩子结点，则从中选出最大的一个与a交换。当a来到下一层的时候重复上述过程，直到a的孩子结点值都小于a的值为止。
2. 将当前无序序列中的第一个关键字，反映在树中是根结点（假设为a）与无序序列中最后一个关键字交换（假设为b)。a进入有序序列，到达最终位置。无序序列中关键字减少1个，有序序列中关键字增加1个。此时只有结点b可能不满足堆的定义，对其进行调整。
3. 重复第2步，直到无序序列中的关键字剩下1个时排序结束。

三、Java代码实现

package datastructure;


import java.util.Arrays;
import java.util.Random;

public class HeapSort {

    /**
     * @param R    R中存储的是一棵完全二叉树，关键字的存储从1开始。序列存储成完全二叉树，子节点的序号刚好是父节点序号值的两倍
     * @param low
     * @param high
     * @description Sift函数完成在数组R[low]到R[high]的范围内对在位置low上的结点进行调整
     */
    static void Sift(int[] R, int low, int high) {
        //R[j]是R[i]的左孩子结点
        int i = low, j = 2 * i;
        int temp = R[i];
        while (j <= high) {
            //若右孩子较大，则把j指向右孩子，j变为2*i+1
            if (j < high && R[j] < R[j + 1]) {
                ++j;
            }
            if (temp < R[j]) {
                //将R[j]调整到双亲结点的位置
                R[i] = R[j];
                //修改i和j的值以便继续向下调整
                i = j;
                j = 2 * i;
            } else {
                break; //调整结束
            }
        }
        //temp存储的是被调整节点的值，这里将其放入最终的位置
        R[i] = temp;
    }

    static void heapSort(int R[], int n) {
        int i;
        int temp;
        /**
         * 建立初始堆：对所有的非叶子结点进行调整，由于是用下标为1开始的数组存储的序列，所有第一个非叶子结点在数组中的下标值是len[nums] / 2,
         * 最后一个非叶子结点，即根结点的下标值为1.
         */
        for (i = n / 2; i >= 1; --i) {
            Sift(R, i, n);
        }
        System.out.println("对初始序列调整后得到的大顶堆是：");
        System.out.println(Arrays.toString(R));
        // 进行n-1次循环，完成堆排序
        for (i = n; i >= 2; --i) {
            temp = R[1];
            R[1] = R[i];
            R[i] = temp;
            //在减少了1个关键字的无序序列中进行调整
            Sift(R, 1, i - 1);
        }
    }

    public static void main(String[] args) {
        Random random = new Random(47);
        int[] nums = new int[11];
        for (int i = 1; i < nums.length; i++) {
            nums[i] = random.nextInt(100);
        }
        System.out.println(Arrays.toString(nums));
        heapSort(nums, nums.length - 1);
        System.out.println("After sorted:");
        System.out.println(Arrays.toString(nums));
    }
}

三、性能分析

1. 时间复杂度分析
   对于函数Sift，显然j走了一条从当前结点到叶子结点的路径，完全二叉树的高度为 ⌈log₂(n+1)⌉ ，即对每个结点调整的时间复杂度为O(log₂n)。对于函数heapSort()，基本操作总次数应该是两个并列的for循环的基本操作次数之和，第一个for循环的基本操作次数为O(log₂n)n/2，第二个循环的基本操作次数是O(log₂n)(n-1），因此整个算法的基本操作次数为O(log₂n)n/2+O(log₂n)(n-1)，其简化后的时间复杂度为O(nlog₂n)。
2. 空间复杂度分析
   算法所需的辅助存储空间不随待排序列规模的变化而变化，是个常量，所以空间复杂度为O(1)。
   堆排序在最坏情况下的时间复杂度也是O(nlog₂n)，这是它相对于快速排序的最大优点，堆排序的空间复杂度为O(1)，在所有的时间复杂度为O(nlog₂n)的排序中是最小的。堆排序适合的场景是关键字数很多的情况，典型的例子是从10000个关键字中选出前10个最小的，这种情况用堆排序最好。如果关键字数较少，则不提倡使用堆排序。