堆排序原理及算法代碼詳解

package com.luna.sort;
public class HeapSortMaxAndMin{
	public static void main(String[] args) {
		int[] array = { 19, 38, 7, 36, 5, 5, 3, 2, 1, 0, 56 };
		System.out.println("排序前:");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + ",");
		}
		System.out.println();
		System.out.println("分割線---------------");
		heapSort(array);
		System.out.println("排序後:");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + ",");
		}
	}
	public static void heapSort(int[] array) {
		if (array == null || array.length == 1)
			return;
		buildArrayToHeap(array); //將數組元素轉化為大頂堆/小頂堆
		for (int i = array.length - 1; i >= 1; i--) {
			// 經過上面的一些列操作，目前array[0]是當前數組裡最大的元素，需要和末尾的元素交換，然後拿出最大的元素
			swap(array, 0, i);
			/**
			 * 交換完後，下次遍歷的時候，就應該跳過最後一個元素，也就是最大的那個
			 * 值，然後開始重新構建最大堆堆的大小就減去1，然後從0的位置開始最大堆
			 */
//			buildMaxHeap(array, i, 0);
			buildMinHeap(array, i, 0);
		}
	}
	// 構建堆
	public static void buildArrayToHeap(int[] array) {
		if (array == null || array.length == 1)
			return;
		//遞推公式就是 int root = 2*i, int left = 2*i+1, int right = 2*i+2;
		int cursor = array.length / 2;
		for (int i = cursor; i >= 0; i--) { // 這樣for循環下，就可以第一次排序完成
//			buildMaxHeap(array, array.length, i);
			buildMinHeap(array, array.length, i);
		}
	}
	//大頂堆
	public static void buildMaxHeap(int[] array, int heapSieze, int index) {
		int left = index * 2 + 1; // 左子節點
		int right = index * 2 + 2; // 右子節點
		int maxValue = index; // 暫時定在Index的位置就是最大值
		// 如果左子節點的值，比當前最大的值大，就把最大值的位置換成左子節點的位置
		if (left < heapSieze && array[left] > array[maxValue]) {
			maxValue = left;
		}
		// 如果右子節點的值，比當前最大的值大，就把最大值的位置換成右子節點的位置
		if (right < heapSieze && array[right] > array[maxValue]) {
			maxValue = right;
		}
		// 如果不相等說明，這個子節點的值有比自己大的，位置發生瞭交換瞭位置
		if (maxValue != index) {
			swap(array, index, maxValue); // 就要交換位置元素
			// 交換完位置後還需要判斷子節點是否打破瞭最大堆的性質。最大堆性質：兩個子節點都比父節點小。
			buildMaxHeap(array, heapSieze, maxValue);
		}
	}
	//小頂堆
	public static void buildMinHeap(int[] array, int heapSieze, int index) {
		int left = index * 2 + 1; // 左子節點
		int right = index * 2 + 2; // 右子節點
		int maxValue = index; // 暫時定在Index的位置就是最小值
		// 如果左子節點的值，比當前最小的值小，就把最小值的位置換成左子節點的位置
		if (left < heapSieze && array[left] < array[maxValue]) {
			maxValue = left;
		}
		// 如果右子節點的值，比當前最小的值小，就把最小值的位置換成左子節點的位置
		if (right < heapSieze && array[right] < array[maxValue]) {
			maxValue = right;
		}
		// 如果不相等說明這個子節點的值有比自己小的，位置發生瞭交換瞭位置
		if (maxValue != index) {
			swap(array, index, maxValue); // 就要交換位置元素
			// 交換完位置後還需要判斷子節點是否打破瞭最小堆的性質。最小性質：兩個子節點都比父節點大。
			buildMinHeap(array, heapSieze, maxValue);
		}
	}
	// 數組元素交換
	public static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
}

import java.util.Arrays;
public class MaxHeapSort {
    private int[] arr;
    public MaxHeapSort(int[] arr){
        this.arr = arr;
    }
    /**
     * 堆排序的主要入口方法，共兩步。
     */
    public void sort(){
        /*
         *  第一步：將數組堆化
         *  beginIndex = 第一個非葉子節點。
         *  從第一個非葉子節點開始即可。無需從最後一個葉子節點開始。
         *  葉子節點可以看作已符合堆要求的節點，根節點就是它自己且自己以下值為最大。
         */
        int len = arr.length - 1;
        int beginIndex = (len - 1) >> 1; 
        for(int i = beginIndex; i >= 0; i--){
            maxHeapify(i, len);
        }
        /*
         * 第二步：對堆化數據排序
         * 每次都是移出最頂層的根節點A[0]，與最尾部節點位置調換，同時遍歷長度 - 1。
         * 然後從新整理被換到根節點的末尾元素，使其符合堆的特性。
         * 直至未排序的堆長度為 0。
         */
        for(int i = len; i > 0; i--){
            swap(0, i);
            maxHeapify(0, i - 1);
        }
    }
    private void swap(int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    /**
     * 調整索引為 index 處的數據，使其符合堆的特性。
     * @param index 需要堆化處理的數據的索引
     * @param len 未排序的堆（數組）的長度
     */
    private void maxHeapify(int index,int len){
        int li = (index << 1) + 1; // 左子節點索引
        int ri = li + 1;           // 右子節點索引
        int cMax = li;             // 子節點值最大索引，默認左子節點。
        if(li > len) return;       // 左子節點索引超出計算范圍，直接返回。
        if(ri <= len && arr[ri] > arr[li]) // 先判斷左右子節點，哪個較大。
            cMax = ri;
        if(arr[cMax] > arr[index]){
            swap(cMax, index);      // 如果父節點被子節點調換，
            maxHeapify(cMax, len);  // 則需要繼續判斷換下後的父節點是否符合堆的特性。
        }
    }
    /**
     * 測試用例
     * 輸出：
     * [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]
     */
    public static void main(String[] args) {
        int[] arr = new int[]{3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};        
        new MaxHeapSort(arr).sort();        
        System.out.println(Arrays.toString(arr));
    }
}