java - 堆排序

堆排序思想：
1、將待排序序列構造成一個大頂堆，此時整個序列的最大值就是堆的根節點。
2、將其與末尾元素進行交換，此時末尾就是最大值
3、然後將剩餘n-1個元素重新構造成一個堆，這樣會得到n個元素的次小值
4、如此反覆執行，便能得到一個有序序列了

package sort;

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[] {6,8,-4,4,6,8,5,9};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void heapSort(int[] arr) {
        //開始位置是最後一個非葉子節點，即最後一個節點的父節點
        int start = arr.length/2 -1;
        //調整爲大頂堆
        for(int i=start;i>=0;i--) {
            toMaxHeap(arr, arr.length, i);
        }
        //經過上面的操作後，已經把數組變成一個大頂堆，把根元素和最後一個元素進行調換
        for(int i=arr.length-1;i>0;i--) {
            swap(arr,0,i);
            toMaxHeap(arr, i, 0);
        }
    }

    /**
     * @param arr     要排序的數組
     * @param size    調整的元素個數
     * @param index   從哪裏開始調整
     */
    public static void toMaxHeap(int[] arr,int size,int index) {
        //獲取左右節點的索引
        int leftNodeIndex = 2*index+1;
        int rightNodeIndex = 2*index+2;
        //查找最大節點所對應的索引
        int maxIndex = index;

        if(leftNodeIndex < size && arr[leftNodeIndex] > arr[maxIndex]) {
           maxIndex = leftNodeIndex;
        }
        if(rightNodeIndex < size && arr[rightNodeIndex] > arr[maxIndex]) {
            maxIndex = rightNodeIndex;
        }
        //調換位置
        if(maxIndex!=index) {
            swap(arr,index,maxIndex);
            //調換之後，可能會影響到下面的子樹，使之不是大頂堆，還需要再次調換
            toMaxHeap(arr, size, maxIndex);
        }
    }

    //交換數組元素
    public static void swap(int arr[],int a,int b){
        arr[a] = arr[a] + arr[b];
        arr[b] = arr[a] - arr[b];      //把arr[a]賦值給arr[b]
        arr[a] = arr[a] - arr[b];      //剩下的就是arr[a]
    }

}