【排序算法】03堆排序

接上文： 【排序算法】02归并排序

堆排序是对选择排序的改进。

--- 适用于：
    基本有序（正序或反序）的情况。

--- 堆的定义：
对于数列{r[1], r[2], ... , r[n]}，
小顶堆：满足r[i] <= r[2i] && r[i] <= r[2i+1]，r[1]最小
大顶堆：满足r[i] >= r[2i] && r[i] >= r[2i+1]，r[1]最大
可将堆看成一颗完全二叉树，按顺序分配的方式进行存储！
r[1]为堆顶，r[n]为堆底。

  时间O(n*log(n))
   空间O(1)
  
--- 堆排序核心：     
在堆顶r[1]和堆底r[n]交换之后，如何将序列{r[1], ..., r[n-1]}重新调整为堆。

--- 堆排序思路：
先建一个初始大顶堆，即可选得一个最大的记录，将其与序列中最后一个记录交换，
之后继续对序列前n-1个记录进行筛选。

向工具类ArraySorterUtils中添加堆排序的实现，代码如下：

package org.liws1.sort;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 数组的排序,这里统一做升序排序
 */
public class ArraySorterUtils {

    private static <T> void swap(T[] datas, int i, int j) {
        if (i == j) return;
        T temp = datas[i];
        datas[i] = datas[j];
        datas[j] = temp;
    }
    
    public static class HeapSorter implements IArraySorter {
        
        @Override public <T extends Comparable<T>> void sort(T[] list) {
            // 1、建立初始大顶堆，并交换堆顶和堆底的记录
            buildFirstHeap(list);
            int len = list.length;
            swap(list, 0, len - 1);
            // 2、反复调整
            for (int i = len - 2; i > 0; i--) {
                heapAdjust(list, 0, i);
                swap(list, 0, i);
            }
        }

        @Override public <T> void sort(T[] list, Comparator<T> comp) {
            // 省略实现，跟sort(T[] list)没差
        }
        
        /** 
         * 将一个无序序列调整为大顶堆[升序用大顶堆]<br>
         * 是一个"自下而上"的过程。
         * 
         * 思路：
         * 对于有n个元素的完全二叉树，[n/2, n-1]均为叶子节点,每个叶子节点都是堆，
         * 所以只要从最后一个非叶子节点[n/2-1]开始，到根节点位置，依次调用heapAdjust
         * ,即可将一个无序序列调整为一个大顶堆。
         */
        private static <T extends Comparable<T>> void buildFirstHeap(T[] datas) {
            int len = datas.length;
            for (int i = len / 2 - 1; i >= 0; i--) {
                heapAdjust(datas, i, len - 1);
            }
        }
        
        /**
         * 在datas[start]不是大顶堆但是其'左子树'和'右子树'都为大顶堆的情况下，
         * 将datas[start ... end]调整为大顶堆。
         * 
         * 注意：x的子节点为2x+1和2x+2 ！
         * @param datas 
         * @param start
         * @param end
         */
        private static <T extends Comparable<T>> void heapAdjust(T[] datas, int start, int end){
            int father = start;
            int largerKid = 2 * father + 1;
            while (largerKid <= end) {     // 有左子节点
                // 1、确定较大子节点
                if (largerKid < end) {    // 且有右子节点
                    if (datas[largerKid].compareTo(datas[largerKid + 1]) < 0) {
                        largerKid = largerKid + 1;
                    }
                }
                // 2、如果父节点记录小于较大子节点记录，则做交换；
                //    否则表示已调整为大顶堆，终止循环。
                if (datas[father].compareTo(datas[largerKid]) < 0) {
                    swap(datas, father, largerKid);

                    father = largerKid;
                    largerKid = 2 * largerKid + 1;
                } else {
                    break;
                }
            }
        }

    }
    
}

测试代码如下：

package org.liws1.sort;

import java.util.Arrays;
import org.junit.Test;

public class _Test {

    private Integer[] datas = { 30, 1, 29, 2, 28, 3, 27, 4, 26, 5, 25, 6, 24, 7,
            23, 8, 22, 9, 21, 10, 20, 19, 15, 18, 12, 17, 11, 16, 14, 13 };

    @Test public void testHeap(){
        new ArraySorterUtils.HeapSorter().sort(datas);
        System.out.println(Arrays.toString(datas));
    } // out:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
}