java八大排序----堆排序

1.堆结构

堆结构的底层实际上就是一个数组，这个数组表示的是一棵完全二叉树，这个二叉树并且满足根节点大于（小于）左右孩子节点

2.堆排序时间复杂度

由于是一颗二叉树，每个节点的操作复杂度是O（logN），所以整颗二叉树的复制度是O（NlogN）

3.sifiDown(int k)

这个方法主要是用来下沉k索引使以k索引为根节点的二叉树满足堆结构，这里采用了递归算法，通过一层层的比较使之满足最大堆的结构，需要注意的是操作tree数组时，叶子节点是不需要进行操作的，而是从最后一个叶子节点的父亲节点开始下沉。
当tree数组满足堆结构时，我们通过遍历操作 取出最大元素，把最后一个元素替换最大元素，然后下沉，所得到的就是一个有序数组

/**
 * Created by upupgogogo on 2018/7/14.下午2:11
 */
public class HeapSort {

    private int tree[];

    private int size;

    public void heapSort(int[] nums){

        tree = new int[nums.length];
        size = tree.length;
        for (int i = 0; i < nums.length; i ++)
            tree[i] = nums[i];

        for (int i = (tree.length - 2) / 2; i >= 0 ; i-- )
            siftDown(i);
        for (int i = 0; i < nums.length; i ++){
            nums[i] = tree[0];
            int k = nums.length - i - 1;
            tree[0] = tree[k];
            size --;
            siftDown(0);
        }
    }

    private void siftDown(int k){

        if (getLeftChild(k) >= size)
            return;
        int j = 0;
        if (getRightChild(k) < size)
            j = tree[getLeftChild(k)] > tree[getRightChild(k)] ? getLeftChild(k) : getRightChild(k);
        else
            j = getLeftChild(k);
        if (tree[k] < tree[j]){
            swap(k,j);
        }
        k = j;
        siftDown(k);

    }


    private int getLeftChild(int index){

        if (index < 0)
            throw new IllegalArgumentException("index is illegal");
        return index * 2 + 1;
    }

    private int getRightChild(int index){

        if (index < 0)
            throw new IllegalArgumentException("index is illegal");
        return index * 2 + 2;
    }

    private void swap(int i, int j){
        if (i < 0 | j < 0 | i >= size | j >= size)
            throw new IllegalArgumentException("index is illegal");

        int temp = tree[i];
        tree[i] = tree[j];
        tree[j] = temp;
    }