八大排序算法之8堆排序算法

堆排序前需要了解的概念

1. 二叉树的知识之顺序存储二叉树，可以见我的这一篇博客

2. 大顶堆和小顶堆的概念
   大顶堆：树中父节点的值大于两个子节点的值（两个子节点不做大小比较，只要是父节点最大即可）
   根据顺序存储二叉树的特点：当是大顶堆时：
   arr[i]>arr[2i+1]&&arr[i]>arr[2i+2] （ i是在数组中的下标，且从零开始）

   小顶堆：树中父节点的值小于两个子节点的值（两个子节点不做大小比较，只要是父节点最小即可）
   根据顺序存储二叉树的特点：当是小顶堆时：
   arr[i]<arr[2i+1]&&arr[i]<arr[2i+2] （ i是在数组中的下标，且从零开始）
   

堆排序的思路：

升序排序思路：

1. 将无序的数组构造成一个大顶堆
2. 整个序列的最大值就是堆顶的根节点
3. 将根节点与无序数组中的最后一个元素交换，此时数组的最后一个数就是最大值
4. 将剩下的无序数组中的n-1个数接着构造成大顶堆，取出根节点，与末尾第n-1个元素交换，就可以排好次大的数。以此类推，反复执行，就可以实现一个有序序列。

堆排序的代码实现：

从堆排序的思路中可以看出需要至少三个步骤

第一步 编写将局部的树变成一个大顶堆的方法

按照从左到右，从下到上的规则进行查找，将一个普通的顺序二叉树变成一个大顶堆二叉树

上图是将一个无序节点变成一个顺序存储二叉树的结构，接下来的目的是以红色方框中的局部树为例，将下标为1的节点的树变成一个局部大顶堆。

/**
     * 功能是：把数组中下标为i的非叶子节点和其左右子树进行调整成为大顶堆例如：
     * @param arr:表示待调整的数组
     * @param i：表示非叶子节点在数组中的索引（下标）例如此例中为1
     * @param length：表示对多少个元素进行调整
     */
 //此方法是用来局部调整大顶堆的，
    public static void adjust(int[] arr,int i,int length){
        int temp=arr[i];
        //k为当前节点的左子节点
        for(int k=2*i+1;k<length;k=k*2+1){
            //先指向了左子节点，如果左子节点小于右子节点，则要记录下来较大的值，此时k指向了右子节点因为50《58，故此时k指向了58
            if (k+1<length&&arr[k] < arr[k+1]) {
                k++;
            }
            //如果左子节点或者右子节点较大，则需要将较大的和该节点互换（例如58>48）
            if(arr[k]>temp){
                arr[i]=arr[k];//将节点换成最大值
                i=k;//用i记录下来更换的最大值来自哪里，以便于和节点的值互换
            }else {
                //如果左子节点或者右子节点没有节点大，则此局部树不需要进行调换，直接退出即可
                break;
            }
            //最后，从哪交换过来的，就把节点放打哪去！
            arr[i]=temp;
        }
    }

此时就可以完成局部的大顶堆变换。

第二步：让整体的树变成一个大顶堆的结构

首先需要判断一共要有多少个局部树进行大顶堆的结构变化：共有3个即;0 1 2所对应的位置也就是arr.length/2个，也就是：

for(int i=arr.length/2-1;i>=0;i--){
            adjust(arr,i,arr.length);
        }

完成了第一次的大顶堆排序

第三步：将大顶堆的根节点（就是数组的第一个元素）与最后一个元素交换

 //通过调整，现在已经把最大值调到了数组的头部。接下来进行和最后一个数交换
        for(int j=arr.length-1;j>0;j--){
            int temp=arr[0];
            arr[0]=arr[j];
            arr[j]=temp;
            //交换完之后，只需要调整第一个子树，就可以把次大的数调到树根节点，然后在进行交换
            adjust(arr,0,j);
        }

测试代码

package com.njupt.zpractice;

import java.util.Arrays;

/**
 * Creat with IntelliJ IDEA
 *
 * @Auther:倔强的加瓦
 * @Date:2021/07/25/14:48
 * @Description:
 */
public class HeapSort {
    public static void main(String[] args) {
        int arr[] = {24, 35, 20, 50, 58, 46, 10};
        sortHeap(arr);
    }

    //堆排序的方法
    public static void sortHeap(int[] arr) {
        //第一次

        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjust(arr, i, arr.length);
        }
        //通过局部调整，现在已经把最大值调到了数组的头部。接下来进行和最后一个数交换
        for (int j = arr.length - 1; j > 0; j--) {
            int temp = arr[0];
            arr[0] = arr[j];
            arr[j] = temp;
            //交换完之后，需要接着调整，把最大的数调到栈顶
            adjust(arr, 0, j);
        }
        System.out.println(Arrays.toString(arr));

    }

    //此方法是用来局部调整大顶堆的
    public static void adjust(int[] arr, int i, int length) {
        int temp = arr[i];
        //k为当前节点的左子节点
        for (int k = 2 * i + 1; k < length; k = k * 2 + 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;
        }
    }
}

结果：

[10, 20, 24, 35, 46, 50, 58]

Process finished with exit code 0

即可以实现排序。