堆排序（大根堆）

堆是一种经过排序的完全二叉树，其中任意非终端节点的数据值均不大于（或不小于）其左孩子和右孩子节点的值。
分为大根堆和小根堆。
java中借助于PriorityQueue可以实现小根堆和大根堆。

它容量没有界限，且默认排序是自然排序，队头元素是最小元素，故可以拿来作为小根堆使用。
也可以借助于comparator比较器来实现大根堆（11是默认的初始用量）。

PriorityQueue <Integer> maxHeap = new PriorityQueue<Integer>(11, new Comparator<Integer>() {  

    @Override  
    public int compare(Integer o1, Integer o2) {  
        // TODO Auto-generated method stub  
        return o2.compareTo(o1);  
    }  

});  

import java.util.Arrays;

public class HeapSort {
    public static void heapSort(int[] arr){
        //创建堆
        for(int i=arr.length/2-1;i>=0;i--){
            adjustHeap(arr,i,arr.length);
        }

        //调整堆
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);
            adjustHeap(arr,0,j);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void adjustHeap(int []arr,int k,int length){       
        for(int i=k*2+1;i<len;i=i*2+1){
            if(i + 1 < len &&arr[i] < arr[i+1]){//这里一定要有i + 1 < len
                i = i + 1;
            }
            if(arr[i] > arr[k]){
                swap(arr,i,k);
                k = i;
            }else
                break;
        }
    }


    public static void main(String[] args) {
        int []arr3 = {4,6,8,5,9};
        heapSort(arr3);
        System.out.println("排序结果：" + Arrays.toString(arr3));

        int a[] = {51,46,20,18,65,97,82,77,50};

        heapSort(a);
        System.out.println("排序结果：" + Arrays.toString(a));

        int []arr = {1,2,3,4,5,6,7,8,9};
        heapSort(arr);
        System.out.println("排序结果：" + Arrays.toString(arr));

        int [] arr2 = {9,8,7,6,5,4,3,2,1};
        heapSort(arr2);
        System.out.println(Arrays.toString(arr2));
    }
}

这里一定要有i + 1 < len，当len=2的时候，i等于1，显然就会出错！
交换了父子节点后，一定注意k = i;，把k置为 i ！

 public static void adjustHeap(int[] arr,int k,int len){
        int tmp = arr[k];
        for(int i=k*2+1;i<len;i=i*2+1){
            if(i + 1 < len &&arr[i] < arr[i+1]){
                i = i + 1;
            }
            if(arr[i] > tmp){
                arr[k] = arr[i];
                k = i;
            }else
                break;
        }
        arr[k] = tmp;
    }

这样也可以，不过没有上一种好理解！其实没什么区别！操作更少些！