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]
    }

}