堆排序（Java版）

堆(Heap)通常是一个可以被看做一颗完全二叉树的数组对象。

完全二叉树的一些定义：

1. 左孩子等于父节点*2+1,例如父节点的索引是0，那么左孩子就是1
2. 右孩子等于父节点*2+2,例如父节点的索引是0，那么右孩子就是2
3. 父节点等于（孩子的索引-1）/2,例如孩子的索引是2，那么父节点就是0

堆分为两种，分别是大根堆和小根堆

大根堆：父节点的值大于或等于子节点的值；（图片是引用的）

小根堆：父节点的值小于或等于子节点的值；（图片是引用的）

堆操作

Insert：某个数现在处在index位置，往上移动，和父节点比较，如果比父节点大，那么就交换位置

heapIfy:给定一个数和堆数组的长度，让这个数往下移动。

堆排序代码如下：

public void heapsort(int[] arr){
        if (arr == null || arr.length<2){return;}
        //将数组变成大根堆
        for (int i = 0; i < arr.length; i++) { //O(N)
            heapInsert(arr,i);  //O(logN)
        }
        int heapSize = arr.length;  //堆数组的长度
        //大根堆第一个数永远是整个堆数组中最大的,把他放在heapSize-1的位置，
        //相当于就排好了。堆数组长度也减一
        swap(arr,0,--heapSize);
        while (heapSize>0){  //O(N)
            //将刚刚换上来的数往下移动，把最大的放在第一个位置
            heapIfy(arr,0,heapSize); //O(logN)
            swap(arr,0,--heapSize); //O(1)
        }
}


public void heapInsert(int[] arr,int index){
        while(arr[index]>arr[(index-1)/2]){  
            //如果比父节点大，就交换，然后让index变成父节点的索引，直到不能换
            swap(arr,index,(index-1)/2);
            index = (index-1)/2;	
        }
}

public void heapIfy(int[] arr,int index,int heapSize){
        //给定一个index和大根堆数组长度，让index往下移动
        int left = index*2+1; //左孩子的坐标
        while (left < heapSize){ //当下面还有孩子的时候
			//把两个孩子中值最大的下标给largest
            int largest = left+1 
Java中也有相应的API 
 
PriorityQueue：底层的结构用的是小根堆
 
堆排序扩展题目
 
已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小，请选择一个合适的排序算法针对这个数据进行排序。
 
public void sort(int[] arr,int k){
        PriorityQueue heap = new PriorityQueue<>();
        int index = 0;
        //一开始先放k个数进入小根堆
        for (;index < k;index++){
            heap.add(arr[index]);
        }
        int i = 0;
        //将其他元素依次加入，并排序
        for (;index < arr.length;i++,index++){
            heap.add(arr[index]);
            arr[i] = heap.poll();
        }
        //将剩下的元素排序
        while (!heap.isEmpty()){
            arr[i++] = heap.poll();
        }
}