堆排序

利用数组和二叉树的相互转化，可以利用树结构的特点，进行排序
测试了速度。因为要经常交换。所以速度和希尔排序比慢了2倍

package a;

import sun.security.util.Length;

import java.util.Arrays;

public class HeapSortDemo {
    public static void main(String[] args) {
        int var = 8000000;
        int[] arr = new int[var];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random()*800000000);

        }
        long sta = System.currentTimeMillis();
//        int[] arr = {4, 6, 8,5,  9,-10,100,87,93,1986756,-1000};
        heapSort(arr);
        long end = System.currentTimeMillis();
        System.out.println(end-sta);
//        System.out.println(Arrays.toString(arr));

    }

    private static void heapSort(int[] arr) {
        System.out.println("begin");
//        swap(arr, 1, arr.length);
//        System.out.println(Arrays.toString(arr));
//        swap(arr, 0, arr.length);
int temp = 0;//用于交换
        for (int i = arr.length/2-1; i >= 0 ; i--) {
            swap(arr,i, arr.length);
        }//一次排序完成 大顶对

        for (int j = arr.length-1; j>0; j--) {//因为是排序的次数。所以减1
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;//现在交换完了，就是最上面的那个数有点问题，其他都没变，所以没问题。
            swap(arr,0,j);//已经调整完成一个了，所以是  length-1，现在j 正好是。
        }





    }

    private static void swap(int[] arr, int index,int len) {
        int temp = arr[index];
        for(int k = index*2+1;k<len;k = k*2+1) {//已经是移动后的子节点了
            if ((k+1)<len&&arr[k] < arr[k + 1]) {
                k++;//也就是找到那个最大值。
            }

            if (arr[k] > temp) {//总是跟最初的那个值比较。也就是子节点的值
                arr[index]=arr[k];//将大的值移动到父节点
                index=k;//占领移动后的位置。
            }else {
                break;
            }
        }
        arr[index] = temp;



    }
}