排序篇--堆排序

算法描述:

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点（小根堆与大根堆）。

实现逻辑:

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；

由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

代码部分：

import java.lang.reflect.Array;
import java.util.Arrays;

public class HeapSort {

    //堆排序
    public static void heapsort(int[] arr){

        if (arr == null || arr.length < 2){
            return;
        }

        //建立堆
        for (int i = 0;i < arr.length; i++){
            heapInsert(arr,i);
        }

        //排序部分 每次取根节点（最大值） 然后在重新heapify 入此循环，数组即可变成有序
        int size = arr.length;
        swap(arr,0,--size);
        while (size > 0){
            heapify(arr,0 ,size);
            swap(arr,0,--size);
        }
    }

    //往堆上添加节点并与父节点比较大小  大根堆 大则向上跑 并更新父节点
    //           父节点 i
    //左孩子 2i + 1  右孩子2i+2
    public static void heapInsert(int[] arr, int index){
        while(arr[index] > arr[(index -1) / 2]){
            swap(arr,index,(index -1) / 2 );
            index = (index -1) / 2;
        }
    }

    //堆的自适应 某个父节点变小了 自动调节为大小根堆
    // @index 父节点位置
    // @堆的大小
    public static void heapify(int[] arr, int index, int size){
        int left = index * 2 + 1;
        while (left < size) {
            //找出孩子节点较大的
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            //孩子节点较大的 和 父节点比较 选出最大的
            largest = arr[largest] > arr[index] ? largest : index;
            //最大是本身 直接跳出
            if(largest == index){
                break;
            }
            swap(arr,largest,index);
            //交换后 继续向下比较调动
            index = largest;
            left = index * 2 + 1;
        }
    }

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