堆排序

1、堆排序定义

    n个关键字序列K_l，K₂，…，K_n称为堆，当且仅当该序列满足如下性质(简称为堆性质)：
    (1) k_i≤K_2i且k_i≤K_2i+1

    (2)K_i≥K_2i且k_i≥K_2i+1(1≤i≤ )
    若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

    大顶堆和小顶堆

    根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆。
    根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大根堆。
注意：
    ①堆中任一子树亦是堆。
    ②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可定义k叉堆。

2、堆排序动画演示

3、堆排序算法的基本思想

（1）用大顶堆排序的基本思想
① 先将初始文件R[1..n]建成一个大顶堆，此堆为初始的无序区 。
② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key 。
③ 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
    ……
直到无序区只有一个元素为止。
（2）大顶堆排序算法的基本操作
① 建初始堆：将R[1..n]构造为初始堆；
② 堆调整：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆。
注意：
①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。
②用小顶堆排序与利用大顶堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻，堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。

4、实现代码  

 

//最大堆排序
public class MaxHeapProblem {

    public static void buildHeap(int a[]) {
        int heapSize = a.length;
        int filter = (int) Math.floor(heapSize / 2);
        // i从第一个非叶子结点开始
        for (int i = filter - 1; i >= 0; i--) {
            heapAdjust(a, i, heapSize);
        }
    }

    // 已知H.r[i...heapSize]中记录的关键字除H.r[i]外，均满足最大堆结构
    public static void heapAdjust(int arr[], int i, int heapSize) {
        // 当前待调整的元素
        int tmp = arr[i];
        // 该元素的左孩子
        int index = 2 * i + 1;
        while (index < heapSize) {
            // 如果右孩子大于左孩子,则index+1，即交换右孩子和双亲节点
            if (index + 1 < heapSize && arr[index] < arr[index + 1]) {
                index = index + 1;
            }
            if (arr[i] < arr[index]) {
                // 交换孩子和双亲节点
                arr[i] = arr[index];
                
                // 重新赋初值
                i = index;
                index = 2 * i + 1;
            } 
            // 已经是最大堆
            else {
                break;
            }
            // 把双亲值赋给孩子节点
            arr[i] = tmp;
        }
    }
    
    private void heapAdjust2(int[] arr, int i, int heapSize) {
        int maxIndex = i;
        if (2 * i + 1 <= heapSize - 1 && arr[2 * i + 1] > arr[i])
            maxIndex = 2 * i + 1;
        if (2 * i + 2 <= heapSize - 1 && arr[i * 2 + 2] > arr[maxIndex])
            maxIndex = 2 * i + 2;
        if (maxIndex != i) {
            int temp = arr[maxIndex];
            arr[maxIndex] = arr[i];
            arr[i] = temp;
            heapAdjust2(arr, maxIndex, heapSize);
        }
        
    }

    public static void heapSort(int a[]) {
        int heapSize = a.length;
        for (int i = heapSize - 1; i > 0; i--) {
            // 交换堆顶和最后一个元素
            int tmp = a[0];
            a[0] = a[i];
            a[i] = tmp;
            // 在heapSize范围内根结点的左右子树都已经是最大堆,所以只需看新交换的堆顶元素是否满足最大堆结构即可。
            // 将H.r[0...i]重新调整为最大堆
            heapAdjust(a, 0, i);
        }
    }

    public static void main(String[] args) {
        int arr[] = new int[] { 6, 5, 3, 1, 8, 7, 2, 4 };
        buildHeap(arr);
        System.out.println("初始建立的最大堆是:");
        for (int data : arr)
            System.out.print(data + " ");
        System.out.println();
        System.out.println("堆经过筛选调整后，排序结果为:");
        heapSort(arr);
        for (int data : arr)
            System.out.print(data + " ");
    }

}

 5、复杂度分析

   堆排序的平均时间复杂度和最坏时间复杂度均为：O(nlgn)

  参考资料：

http://www.cnblogs.com/rollenholt/archive/2012/04/15/2450175.html

http://blog.csdn.net/morewindows/article/details/6709644