算法——堆排序

前言

为了学习面试中常常要考察到的堆排序，在网上搜索了很多篇资料，才大致搞懂了堆排序的原理。现在作出总结，以防日后忘记。

介绍

堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

特点

• 时间复杂度
  • 最好情况：O(n$lo{g}_{2}n$)
  • 平均情况：O(n$lo{g}_{2}n$)
  • 最坏情况：O(n$lo{g}_{2}n$)
• 空间复杂度：O(1)
• 稳定性：不稳定

基本思想

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

• 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
• 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

实现

假设存在这样一个堆a[7]，堆中存在有7个10以下的数：

a[7] = [5,2,7,3,6,1,4];

这里假设构建的是大堆顶。

1. 入堆
   1. 将5置为堆顶，二叉树图如下：
      
   2. 按照从左往右的顺序，置入2，并把它变成左叶子节点。因为2<5，所以不用变换顺序，二叉树图如下：
      
   3. 继续置入数字，这里置入7，由于5<7，所以需要与根节点切换顺序，树状图如图所示：
      
   4. 继续置入数字，这里置入3，这里的3是2的左叶子节点，所以要跟2比较，而不是7！由于2<3，所以需要与根节点切换顺序，树状图如图所示：
      
   5. 继续置入数字，这里置入6，由于3<6，所以需要与根节点切换顺序，树状图如图所示：
      
   6. 继续置入数字，这里置入1，由于1<5，所以不用变换顺序，二叉树图如下：
      
   7. 继续置入数字，这里置入4，由于4<5，所以不用变换顺序，二叉树图如下：
      
2. 出堆
   1. 首先将7出堆，二叉树图如下：
      
   2. 重构二叉树，根据从右往左，从下往上的原则，需要将4变成顶层根节点，但4<6（左子节点，虽然4<5，但是6>5，所以优先和左子节点比较），所以当4换到根节点时，还需要跟6交换位置，才符合大顶堆的特性。二叉树图如下：
      
   3. 将6出堆，继续重构二叉树。根据步骤2，寻找到1需要成为顶层根节点，但1<5，还需要跟6交换位置，才符合大顶堆的特性。二叉树图如下：
      
   4. 重复以上步骤，直到树中没有任何节点为止，即会得到排序好的数列

总结

1. 创建一个堆，H[0…n-1]
2. 按照从左到右，从上到下的顺序，进行入堆操作，并且保证父节点大于（大顶堆）或者小于（小顶堆）的顺序进行调整
3. 按照从右到左，从下到上的顺序，进行出堆操作，在取出堆顶元素的同时，需要保证完全二叉树以及大顶堆或者小顶堆的特性（注意：每次取出堆顶的元素都要排在序列的最后，也就是说，是倒着放进去）

代码实现

这里仅列出用Java代码实现的版本，其他版本可以参考网上的其他资料

    /**
    * 选择排序-堆排序
    * @param array 待排序数组
    * @return 已排序数组
    */
    public static int[] heapSort(int[] array) {
        //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
        for (int i = array.length / 2 - 1; i >= 0; i--) {  
            adjustHeap(array, i, array.length);  //调整堆
        }
  
        // 上述逻辑，建堆结束
        // 下面，开始排序逻辑
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换,作用是去掉大顶堆
            // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
            swap(array, 0, j);
            // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
            // 而这里，实质上是自上而下，自左向右进行调整的
            adjustHeap(array, 0, j);
        }
        return array;
    }
  
    /**
    * 整个堆排序最关键的地方
    * @param array 待组堆
    * @param i 起始结点
    * @param length 堆的长度
    */
    public static void adjustHeap(int[] array, int i, int length) {
        // 先把当前元素取出来，因为当前元素可能要一直移动
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
            // 让k先指向子节点中最大的节点
            if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
                k++;
            }
            //如果发现结点(左右子结点)大于根结点，则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 如果子节点更换了，那么，以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
                i = k;  //这一步决定了下一个步骤执行到的是左子树还是右子树
            } else {  //不用交换，直接终止循环
                break;
            }
        }
    }
  
    /**
    * 交换元素
    * @param arr
    * @param a 元素的下标
    * @param b 元素的下标
    */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }