八大排序终极篇之堆排序（Java实现）

八大排序：

1. 冒泡排序
2. 选择排序
3. 插入排序
4. 希尔排序
5. 快速排序
6. 归并排序
7. 基数排序
8. 堆排序

堆排序基本介绍：

1. 堆排序是利用对这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平局时间复杂度均为O（nlogn），它也是不稳定排序。
2. 堆是具有以下性质的完全二叉树，每个节点的值都大于
   或等于其左右孩子节点的值，称为大顶堆，注意：没有要求节点的左孩子的值和右孩子的值的大小关系。
3. 每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆
4. 一般升序用大顶堆，降序用小顶堆

堆排序的基本思想：

堆排序的基本思想是：

1. 将待排序序列构造成一个大顶堆
2. 此时，整个序列的最大值就是堆顶的根节点
3. 将其与末尾元素进行交换，此时末尾就是最大值。
4. 然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便可以得到一个有序序列了。

可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了
堆排序的初始代码：

package DataStructures.tree;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class HeapSort {
    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 5, 9,-1,90,100,-50};//要求将数组进行升序排列
        heapSort(arr);
    }

    //编写一个堆排序的方法
    public static void heapSort(int[] arr) {
        int temp = 0;
        System.out.println("堆排序");
       /* //分步完成
        adjustHeap(arr,1, arr.length);
        System.out.println("第一次:"+ Arrays.toString(arr));

        adjustHeap(arr,0, arr.length);
        System.out.println("第二次:"+ Arrays.toString(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--) {
            //交换
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr,0, j);
        }
        System.out.println("数组=" + Arrays.toString(arr));
    }
    /*

     *arr 待调整的数组
     * i  表示非叶子结点在数组中的索引
     * length 表示对多少个元素进行调整，length是在逐渐减少
     */

    //将一个数组（二叉树），调整成一个大顶堆
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];//先取出当前元素的值，保存在临时变量
        //开始调整
        //说明
        /*
         * 1.k = i * 2 + 1是i节点的左子节点
         * */
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                //说明左子节点的值小于右子节点的值
                k++;//k指向右子节点
            }
            if (arr[k] > temp) {
                //如果子节点大于父节点
                arr[i] = arr[k];//把较大的值赋给当前的这个节点让后让i指向k
                i = k;//继续循环比较
            } else {
                break;
            }
        }
        //当for循环结束后，我们将以i为父节点的树的最大值，放在了最顶（局部）
        arr[i] = temp;//将temp值放到调整后的位置

    }
}

测试堆排序的时间消耗：

package DataStructures.tree;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class HeapSort {
    public static void main(String[] args) {
        //int[] arr = {4, 6, 8, 5, 9,-1,90,100,-50};//要求将数组进行升序排列
        int[] arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arr[i] = (int) (Math.random() * 8000000);//生成80000个随机数【0,80000000】
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data1Str = simpleDateFormat.format(data1);
        System.out.println("排序前的时间：" + data1Str);
        //bubbleSort(arr);
        heapSort(arr);
        Date data2 = new Date();
        //new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String data2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间：" + data2Str);
    }

    //编写一个堆排序的方法
    public static void heapSort(int[] arr) {
        int temp = 0;
        System.out.println("堆排序");
       /* //分步完成
        adjustHeap(arr,1, arr.length);
        System.out.println("第一次:"+ Arrays.toString(arr));

        adjustHeap(arr,0, arr.length);
        System.out.println("第二次:"+ Arrays.toString(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--) {
            //交换
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            adjustHeap(arr,0, j);
        }
        //System.out.println("数组=" + Arrays.toString(arr));
    }
    /*

     *arr 待调整的数组
     * i  表示非叶子结点在数组中的索引
     * length 表示对多少个元素进行调整，length是在逐渐减少
     */

    //将一个数组（二叉树），调整成一个大顶堆
    public static void adjustHeap(int[] arr, int i, int length) {
        int temp = arr[i];//先取出当前元素的值，保存在临时变量
        //开始调整
        //说明
        /*
         * 1.k = i * 2 + 1是i节点的左子节点
         * */
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                //说明左子节点的值小于右子节点的值
                k++;//k指向右子节点
            }
            if (arr[k] > temp) {
                //如果子节点大于父节点
                arr[i] = arr[k];//把较大的值赋给当前的这个节点让后让i指向k
                i = k;//继续循环比较
            } else {
                break;
            }
        }
        //当for循环结束后，我们将以i为父节点的树的最大值，放在了最顶（局部）
        arr[i] = temp;//将temp值放到调整后的位置

    }
}