堆排序

一：堆排序

1：堆排序的特点

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

每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。

大顶堆

小顶堆

升序采用大顶堆，降序采用小顶堆

2：堆排序的基本思想

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

2.1：构造初始堆。将给定无序序列构造成一个大顶堆

原始的数组 [4, 6, 8, 5, 9]

• 假设给定无序序列结构如下

• 此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点arr.length/2-1=5/2-1=1，也就是下面的 6 结点），从左至右，从下至上进行调整

• 找到第二个非叶节点 4，由于[4,9,8]中 9 元素最大，4 和 9 交换

• 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中 6 最大，交换 4 和 6。

此时，我们就将一个无序序列构造成了一个大顶堆。

步骤二 将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

• 将堆顶元素 9 和末尾元素 4 进行交换

• 重新调整结构，使其继续满足堆定义

• 再将堆顶元素 8 与末尾元素 5 进行交换，得到第二大元素 8.

• 后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序

三：堆排序的代码实现

HeapSort实体类

package com.github.heap;

import java.util.Arrays;

/**
 * @author lizhangyu
 * @version 1.0
 * @description
 * @date 2021/3/12 11:46
 */
public class HeapSort {

    public static void main(String[] args) {
        int[] arr = {9, 3, 6, 7, 5, 8, 1, 0, 4, 2};
        int[] arr1 = {9, 3, 6, 7, 5, 8, 1, 0, 4, 2};

        //先构建大顶堆
        for (int i = arr.length / 2 -1; i >= 0; i--) {
            adjustMaxHead(arr, i, arr.length);
        }

        //1. 将堆顶元素和末尾元素进行交换，将最大元素沉到数组末尾
        //2. 重新将剩下的元素调整为大顶堆，再重复1，2操作
        for (int j = arr.length - 1; j > 0; j--) {
            int temp = arr[0];
            arr[0] = arr[j];
            arr[j] = temp;
            adjustMaxHead(arr, 0, j);
        }

        System.out.println("通过大顶堆调整之后的结果=" + Arrays.toString(arr));

        //先构建小顶堆
        for (int i = arr1.length / 2 -1; i >= 0; i--) {
            adjustMinHead(arr1, i, arr1.length);
        }

        //1. 将堆顶元素和末尾元素进行交换，将最小元素沉到数组末尾
        //2. 重新将剩下的元素调整为小顶堆，再重复1，2操作
        for (int j = arr1.length - 1; j > 0; j--) {
            int temp = arr1[0];
            arr1[0] = arr1[j];
            arr1[j] = temp;
            adjustMinHead(arr1, 0, j);
        }

        System.out.println("通过小顶堆调整之后的结果=" + Arrays.toString(arr1));

    }

    /**
     * 1. 首先左右节点进行比较，将大的节点取出
     * 2。 将大的节点和当前节点进行比较，如果小于当前节点，则不做处理，当大于，则进行交换
     * 3. 如果存在替换，则将替换的节点为下一个循环的当前节点，继续执行1.2.3步骤，如果不存在则跳出循环
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustMaxHead(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && arr[k] < arr[k+1]) {
                k++;
            }

            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;
            }else {
                break;
            }
        }
        arr[i] = temp;
    }

    /**
     * 1. 首先左右节点进行比较，将小的节点取出
     * 2。 将小的节点和当前节点进行比较，如果大于当前节点，则不做处理，当小于，则进行交换
     * 3. 如果存在替换，则将替换的节点为下一个循环的当前节点，继续执行1.2.3步骤，如果不存在则跳出循环
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustMinHead(int[] arr, int i, int length) {
        int temp = arr[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && arr[k] > arr[k+1]) {
                k++;
            }

            if (arr[k] < temp) {
                arr[i] = arr[k];
                i = k;
            }else {
                break;
            }
        }
        arr[i] = temp;
    }

}

HeapSortDemo实体类

package com.github.heap;

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

/**
 * @author lizhangyu
 * @version 1.0
 * @description
 * @date 2021/3/12 16:44
 */
public class HeapSortDemo {

    public static void main(String[] args) {
        // 创建要给 80000 个的随机的数组
        int[] arr = new int[8000000];
        for (int i = 0; i < 8000000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }
        Date data1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String date1Str = simpleDateFormat.format(data1); System.out.println("排序前的时间是=" + date1Str);
        headSort(arr);
        Date data2 = new Date();
        String date2Str = simpleDateFormat.format(data2);
        System.out.println("排序后的时间是=" + date2Str);
    }

    public static void headSort(int[] arr) {
        HeapSort heapSort = new HeapSort();
        //先构建大顶堆
        for (int i = arr.length / 2 -1; i >= 0; i--) {
            heapSort.adjustMaxHead(arr, i, arr.length);
        }

        //1. 将堆顶元素和末尾元素进行交换，将最大元素沉到数组末尾
        //2. 重新将剩下的元素调整为大顶堆，再重复1，2操作
        for (int j = arr.length - 1; j > 0; j--) {
            int temp = arr[0];
            arr[0] = arr[j];
            arr[j] = temp;
            heapSort.adjustMaxHead(arr, 0, j);
        }
    }
}

运行结果

排序前的时间是=2021-03-12 16:52:59
排序后的时间是=2021-03-12 16:53:01

八百万的数据进行排序耗时两秒，从这里可以看出堆排序的效率很高。