【数据结构与算法】——排序算法之堆排序

前言
  🎄：CSDN的小伙伴们大家好，今天跟大家分享一个排序算法——堆排序。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
  🏡：博客主页：空山新雨后的java知识图书馆
  ☀️：晴朗的天气
  📝一个人必须经过一番刻苦奋斗，才会有所成就。——安徒生📝
  📖上一篇文章：【数据结构与算法】——线索化二叉树）📖
  👏欢迎大家一起学习，进步。加油👊

---

---

一、堆排序

  注意：学习堆排序之前需要对二叉树进行学习，（顺序二叉树和完全二叉树）

1.1、堆排序的基本介绍

  堆的基本概念（大顶堆和小顶堆的概念）：

1. 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复 杂度均为 O(nlogn)，它也是不稳定排序。

2. 堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。

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

4. 大顶堆图示
   

5. 小顶堆图示

6. 一般升序采用大顶堆（从小到大），降序采用小顶堆（从大到小）

1.2、堆排序的基本思想

​ 堆排序的基本思想是：

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

1.3、堆排序的步骤图解说明

要求：给你一个数组 {4,6,8,5,9} , 要求使用堆排序法，将数组升序排序。

  步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。

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

• 1. .假设给定无序序列结构如下
     
• 2. .此时我们从最后一个非叶子结点开始（叶结点自然不用调整，第一个非叶子结点 arr.length/2-1=5/2-1=1，也就是下面的 6 结点），从左至右，从下至上进行调整。
     
• 3. .找到第二个非叶节点 4，由于[4,9,8]中 9 元素最大，4 和 9 交换
     
• 4. 这时，交换导致了子根[4,5,6]结构混乱，继续调整，[4,5,6]中 6 最大，交换 4 和 6。
     

•   此时，我们就得到了一个大顶堆，过程就是叶子结点先对比，大的为待比对的结点，将大的与父节点进行对比，如果该结点小于父节点，则不交换，如果大于父节点，则进行交换。循环进行直到调整到他符合大顶堆的定义即可。

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

• 1. .将堆顶元素 9 和末尾元素 4 进行交换
     
• 2. .重新调整结构，使其继续满足堆定义
     
• 3. .再将堆顶元素 8 与末尾元素 5 进行交换，得到第二大元素 8.
     
• 4. 后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序
     

• 最终我们就会得到一个升序排序的有序数列。

总体思路流程：

• 1).将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

• 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

• 3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，

  直到整个序列有序。

1.4、堆排序java代码实现

要求：给你一个数组 {4,6,8,5,9} , 要求使用堆排序法，将数组升序排序。

package com.studySelf.tree.heapSort;

import java.util.Arrays;

/**
 * @author wang
 * @version 1.0
 * @packageName com.studySelf.tree.heapSort
 * @className HeapSort
 * @date 2022/5/10 20:07
 * @Description 堆排序
 */
public class HeapSort {
    public static void main(String[] args) {
        int arr[] = {4, 6, 8, 5, 9, 22, -45, 999};
        headSortWay(arr);
        headSortWay2(arr);
        /*[4, 5, 6, 8, 9]
          [9, 8, 6, 5, 4]*/
    }


    /**
     * 堆排序升序排序
     */
    public static void headSortWay(int arr[]) {
        int temp = 0;
        /*构建一个大顶堆 因为每一次进去的都是他的非叶子结点，所以用arr.length/2-1就直接定位到最后一个非叶子结点，
         * 循环就可以解决所有的堆的构造*/
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }

        /*n--是控制元素每放一个最大元素到最后面，这个元素就不参与运算了*/
        for (int n = arr.length - 1; n > 0; n--) {
            /*n是树末尾的那一个*/
            temp = arr[n];
            /*将末尾的值给为第一个*/
            arr[n] = arr[0];
            /*将第一个值赋值为末尾的那个值，就完成了末尾的值与第一个值的交换，
             * 在大顶堆中就是最大值与最小值进行了交换*/
            arr[0] = temp;

            /*继续调整堆的结构为大顶堆，直到最后一个值也就是n=0完成排序*/
            adjustHeap(arr, 0, n);
        }
        System.out.println(Arrays.toString(arr));
    }


    /**
     * @param arr    待调整的数组
     * @param i      非叶子结点在数组中的索引
     * @param length 表示有多少个元素进行调整
     * @Date 2022/5/10 20:08
     * @Param
     * @Return void
     * @MetodName adjustHeap
     * @Author wang
     * @Description 构造大顶堆的方法
     */
    public static void adjustHeap(int arr[], int i, int length) {

        /*将当前叶子结点保存到临时变量中，以便于后续交换*/
        int temp = arr[i];

        /*这里的k应该指向的是当前结点的左子结点（因为需要从左子结点开始对比），当k的值大于待调整的数组长度时，循环结束
         * k的值应当走向下一个非叶子结点，因为可能存在下一个非叶子结点*/
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            /*进来首先比较左子结点和右子结点，如果左子结点比右子结点小，那么k就移动到右子结点*/
            if ((k + 1) < length && arr[k] < arr[k + 1]) {
                k++;
            }
            /*接下来比较右子结点和父节点的大小，如果左子结点比父子节点大，那么就交换两个结点的值，
             * 最大的值就到了原来的父子节点，也就达到了我们的目的*/
            if (arr[k] > temp) {
                arr[i] = arr[k];
                /*让i指向k继续循环比较，因为可能存在还有非叶子结点的情况*/
                i = k;
            } else {
                /*那么如果右子结点比父节点小，又加上第一次已经将两个孩子结点比较完毕了，因此，这个
                 * 堆就已经是大顶堆了，无需交换，直接结束即可*/
                break;
            }
        }
        /*当循环结束之后，该交换的已经交换了，那么还有一个空着的结点就是空着的i结点的位置
         * 如果堆没有改动，那么i与temp就是原值
         * 如果堆改动了，k就是i最后的值，由于循环中已经将k的值付给了i，并且k在循环内，无法使用
         * 所以当前的arr【i】就是交换之后空着的那个结点，将temp也就是原来的父节点的值赋给他即可*/
        arr[i] = temp;
    }


    /**
     * 小顶堆的排序降序方法
     */
    public static void headSortWay2(int arr[]) {
        int temp = 0;
        /*构建一个小顶堆*/
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap2(arr, i, arr.length);
        }

        /*n--是控制元素每放一个最大元素到最后面，这个元素就不参与运算了*/
        for (int n = arr.length - 1; n > 0; n--) {
            /*n是树末尾的那一个*/
            temp = arr[n];
            /*将末尾的值给为第一个*/
            arr[n] = arr[0];
            /*将第一个值赋值为末尾的那个值，就完成了末尾的值与第一个值的交换，
             * 在小顶堆中就是最大值与最小值进行了交换*/
            arr[0] = temp;

            /*继续调整剩余的堆的结构为小顶堆，直到最后一个值也就是n=0完成排序
             * 剩余多少个元素参与排序，是由n控制的*/
            adjustHeap2(arr, 0, n);
        }
        System.out.println(Arrays.toString(arr));
    }


    /**
     * 构建小顶堆的方法
     */
    public static void adjustHeap2(int arr[], int i, int length) {
        /*将当前叶子结点保存到临时变量中，以便于后续交换*/
        int temp = arr[i];
        /*这里的k应该指向的是当前结点的左子结点（因为需要从左子结点开始对比），当k的值大于待调整的数组长度时，循环结束
         * k的值应当走向K结点的左子结点，因为可能存在下一个非叶子结点*/
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            /*进来首先比较左子结点和右子结点，如果左子结点比右子结点大，那么k就移动到右子结点，
            因为构建小顶堆的目的是将最小的值移动到父节点*/
            if ((k + 1) < length && arr[k] > arr[k + 1]) {
                k++;
            }
            /*接下来比较右子结点和父节点的大小，如果左子结点比父子节点小，那么就交换两个结点的值，
             * 最大的值就到了原来的父子节点，也就达到了我们的目的*/
            if (arr[k] < temp) {
                arr[i] = arr[k];
                /*让i指向k继续循环比较，因为可能存在还有非叶子结点的情况*/
                i = k;
            } else {
                /*那么如果右子结点比父节点大，又加上第一次已经将两个孩子结点比较完毕了，因此，这个
                 * 堆就已经是小顶堆了，无需交换，直接结束即可*/
                break;
            }
        }
        /*当循环结束之后，该交换的已经交换了，那么还有一个空着的结点就是空着的i结点的位置
         * 如果堆没有改动，那么i与temp就是原值
         * 如果堆改动了，k就是i最后的值，由于循环中已经将k的值付给了i，并且k在循环内，无法使用
         * 所以当前的arr【i】就是交换之后空着的那个结点，将temp也就是原来的父节点的值赋给他即可*/
        arr[i] = temp;

    }
}		/*当循环结束之后，该交换的已经交换了，那么还有一个空着的结点就是空着的i结点的位置
         * 如果堆没有改动，那么i与temp就是原值
         * 如果堆改动了，k就是i最后的值，由于循环中已经将k的值付给了i，并且k在循环内，无法使用
         * 所以当前的arr【i】就是交换之后空着的那个结点，将temp也就是原来的父节点的值赋给他即可*/
        arr[i] = temp;

    }
}

  代码中我将小顶堆也一样完成了，小顶堆的构造唯一的区别就是我们要将一个非叶子结点的值与他的孩子结点进行比较，将最小的放到这个非叶子结点即可，完成小顶堆的构造。