一、原理

? 堆排序是采用數據結構堆進行排序的算法。堆是一種近似完全二叉樹的結構，並同時滿足堆的性質:子節點的鍵值或索引總是小於(或大於)它的父節點。

? 堆中定義以下幾種操作:

? 1) 最大堆調整(Max Heapify):將堆的末端子節點作調整，使得子節點永遠小於父節點 。

? 2) 創建最大堆（Build Max Heap）：將堆中的所有數據重新排序 。

? 3) 堆排序（HeapSort）：移除位在第一個數據的根節點，並做最大堆調整的遞歸運算。

二、代碼實現

package com.jdk8.SortTest;

import java.util.Arrays;

public class Heapsort {
    public static void main(String[] args){
        int[] arrays = new int[]{1,3,2,9,8,7,6,0,4,5,10};
        System.out.println("排序前序列為:" + Arrays.toString(arrays));
        heapOperateSort(arrays);
        System.out.println("排序後序列為:" + Arrays.toString(arrays));
    }

    private static void heapOperateSort(int[] arrays) {

        int i,temp;

        for(i = (arrays.length - 2)/2;i >= 0;i--){
            downSort(arrays,i,arrays.length);
        }

        for(i = arrays.length - 1;i > 0;i-- ){
            temp = arrays[i];
            arrays[i] = arrays[0];
            arrays[0] = temp;

            downSort(arrays,0,i);
        }

    }

    private static void downSort(int[] arrays, int parentIndex, int length) {
        int temp = arrays[parentIndex];
        int childIndex = 2 * parentIndex + 1;
        while(childIndex < length){
            if((childIndex + 1)<length && arrays[childIndex + 1] > arrays[childIndex]){
                childIndex = childIndex + 1;
            }

            if(temp > arrays[childIndex]){
                break;
            }

            arrays[parentIndex] = arrays[childIndex];
            parentIndex = childIndex;
            childIndex = 2 * childIndex + 1;
        }

        arrays[parentIndex] = temp;

    }
}
 

三、復雜度分析

3.1、時間復雜度分析

? 下沈調整的最壞時間復雜度相當於二叉堆的高度，即O(logn)。

? 如上程序所示，堆排序算法分為兩步，第一步生成二叉堆，第二步循環刪除頭元素(即堆頂元素)，將其放到尾部，調節堆產生新的堆頂。

? 第一步，生成二叉堆，進行(n-2)/2次循環，即調用(n-2)/2次downSort方法，即(n-2)/2 * O(logn)等於O(nlogn)。

? 第二步，按程序中示，n-1次循環，即(n-1)次downSort方法，即(n-1)* O(logn),等於O(nlogn)。

? 第一步和第二部是順序關系，即相加關系，因此堆排序的時間復雜度是O(nlogn)。

3.2、空間復雜度

? 堆排序的臨時變量所占用的空間不隨處理數據n的大小改變而改變，即空間復雜度為O(1)。

四、穩定性

? 堆排序是不穩定排序。

排序算法之堆排序