堆排序

---

• JAVA语言实现
• 属于交换排序
• 平均，最好与最坏时间复杂度O($n{\log }_2^n$)
• 辅助空间O(1)
• 不稳定

---

一. 思路

1. 构建初始堆。
2. 交换根与最右端叶子的值，此时最大值已放到最终位置，堆的大小减一。
3. 从根部向下检查，交换比根部值大的值。
4. 反复执行操作2-3，直到的堆的大小为0。

---

二. 代码

import java.util.Arrays;

/**
 * 堆排序
 * 时间复杂度O(nlogn);不稳定
 * @author luyuno_o
 */
public class HeapSort {

    public static void heapSort(int[] arr){
        int len = arr.length;
        if(len<2) return;
        maxHeap(arr,len);//构建初始堆
        len--;
        for(;len>=0;len--){
            swap(arr,0,len);//交换最小的叶子与根，根放到最终位置，因此len减小
            swapNode(arr,0,len);//对交换后的堆从根部向下进行检查
        }
    }

    //构建初始堆
    public static void maxHeap(int[] arr,int len){
        for(int i=(len-1)/2;i>=0;i--){
            swapNode(arr,i,len);
        }
        System.out.println("初始最大堆："+Arrays.toString(arr));
    }

    //由上至下逐个比较父节点与子节点值的大小
    public static void swapNode(int[] arr,int index,int len){
        int maxIndex = index;
        if((index*2+1)<len && arr[index]<arr[index*2+1]){
            maxIndex = index*2+1;
            swap(arr,index,maxIndex);
        }
        if((index*2+2)<len && arr[index]<arr[index*2+2]){
            maxIndex = index*2+2;
            swap(arr,index,maxIndex);
        }
        if(maxIndex != index){//说明父节点发生变动，需要继续向下比较
            swapNode(arr,maxIndex,len);
        }
    }

    //交换数组的成员i与j的值
    public static void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int[] arr = {1,3,20,29,5,7,31,0,33,9};
        System.out.println("初始堆结果："+Arrays.toString(arr));
        heapSort(arr);
        System.out.println("堆排序结果："+Arrays.toString(arr));
    }
}

---

三. 运行结果

初始堆结果：[1, 3, 20, 29, 5, 7, 31, 0, 33, 9]
初始最大堆：[33, 29, 31, 3, 9, 7, 20, 0, 1, 5]
堆排序结果：[0, 1, 3, 9, 5, 7, 20, 29, 31, 33]

---

参考文献

1. 排序算法总结：https://blog.csdn.net/qq_40691562/article/details/88085657

---