算法（五）堆排序

堆的简介

堆是具有特殊性质的完全二叉树，堆主要分为大顶堆和小顶堆。

堆的分类

1. 大顶堆：每个结点的值都大于或等于其左右子结点的值。
   
2. 小顶堆：每个结点的值都小于或者等于其左右子结点的值。
   

堆的逻辑表示

对堆中的结点按层进行标号，然后将这种逻辑结构映射到数组中，在逻辑上，可以用下面公式来描述堆的定义：
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]

堆排序

堆排序的基本思想是：
3. 将待排序的数列构建成一个大顶堆，此时，整个数列的最大值就是堆顶的根节点，然后将其和末尾元素进行交换，此时末尾就是最大值了。
4. 然后将剩下的n-1个元素重新构建成一个堆，重复1步骤。如此反复执行，就能得到一个有序序列了。

算法思路详解

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。
5. 此时，我们就将一个无需序列构造成了一个大顶堆。将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换将堆顶元素9和末尾元素4进行交换
6. 重新调整结构，使其继续满足堆定义，再将堆顶元素8与末尾元素5进行交换，得到第二大元素8，后续过程，继续进行调整，交换，如此反复进行，最终使得整个序列有序。
   

算法实现

package com.xxliao.algorithms.sort.heap_sort;

import java.util.Arrays;

/**
 * @author xxliao
 * @description: 堆排序
 * @date 2024/5/30 16:49
 */
public class HeapSort {

    public static void main(String []args){
        int[] array = {7,6,4,3,5,2,10,9,8};
        System.out.println("排序前："+ Arrays.toString(array));
        sort(array);
        System.out.println("排序后："+Arrays.toString(array));
    }

    /**
     * @description  堆排序
     * @author  xxliao
     * @date  2024/5/30 16:51
     */
    public static void sort(int[] array) {
        // 把无序数组构建成最大堆
        for(int i = array.length/2-1; i >= 0; i--) {//从 length/2 -1 的位置向上（索引值变小）比较。
            adjustHeap(array,i,array.length);
        }
        // 调整对结构,交换堆顶元素和末尾元素，调整新的堆顶
        for(int i = array.length-1; i > 0; i--){
            int temp = array[i];
            array[i] = array[0];
            array[0] = temp;
            adjustHeap(array, 0, i);
        }
    }

    /**
     * @description  根据传入节点，向下比较自己的子节点是否符合大顶堆规则，不符合就交换。
     * @author  xxliao
     * @date  2024/5/30 17:12
     */
    private static void adjustHeap(int[] array, int parentIndex, int length) {
        // temp 保存父索引值
        int temp = array[parentIndex];
        // 左子节点索引
        int child = 2 * parentIndex + 1;

        while(child < length) {
            if(child+1 < length && array[child] < array[child+1]) {
                // 左子节点小于右子节点，将child指向右子节点。
                child++;
            }
            if(temp >= array[child])
                // 父节点大于等于子节点最大的节点，不用管
                break;
            array[parentIndex] = array[child];
            parentIndex = child;
            child = 2 * child + 1;
        }
        array[parentIndex] = temp;
    }
}

测试结果：