【排序算法】排序算法-堆排序（Heap Sort）

最新推荐文章于 2024-10-16 23:53:45 发布

古月日月衣羊

最新推荐文章于 2024-10-16 23:53:45 发布

阅读量855

点赞数

分类专栏：数据结构和算法文章标签：排序算法

本文链接：https://blog.csdn.net/qq_43478625/article/details/121867084

版权

数据结构和算法专栏收录该内容

18 篇文章 1 订阅

订阅专栏

本文介绍了堆排序算法的执行流程及代码实现。堆排序是一种时间复杂度为O(nlogn)的选择排序，分为升序和降序两种。通过构建大顶堆或小顶堆，不断交换堆顶元素与末尾元素并调整堆来实现排序。提供的Java代码展示了如何进行升序和降序的堆排序操作。

摘要由CSDN通过智能技术生成

概述

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

执行流程

将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

代码

public class HeapSort {

    public static void main(String[] args) {

        int[] arr = {9,8,7,6,5,4,3,2,1};
        sort(arr, arr.length);
        System.out.println("升序排列:" + Arrays.toString(arr));
        sort2(arr, arr.length);
        System.out.println("降序排列:" + Arrays.toString(arr));
    }

    //升序
    static void sort(int[] nums, int heapSize) {
        //原地建堆
        buildMaxHeap(nums, heapSize);

        while (heapSize > 1) {
            //交换堆顶元素和尾部元素
            swap(nums, 0, --heapSize);

            //对0位置进行siftDown(恢复堆的性质)
            maxHeapify(nums, 0, heapSize);
        }
    }

    //降序
    static void sort2(int[] nums, int heapSize) {
        //原地建堆
        buildMinHeap(nums, heapSize);

        while (heapSize > 1) {
            //交换堆顶元素和尾部元素
            swap(nums, 0, --heapSize);

            //对0位置进行siftDown(恢复堆的性质)
            minHeapify(nums, 0, heapSize);
        }
    }
    /**
     * 原地建大顶堆
     * @param a
     * @param heapSize
     */
    static void buildMaxHeap(int[] a, int heapSize) {
        for (int i = heapSize / 2 - 1; i >= 0; --i) {
            maxHeapify(a, i, heapSize);
        }
    }

    /**
     * 原地建小顶堆
     * @param a
     * @param heapSize
     */
    static void buildMinHeap(int[] a, int heapSize) {
        for (int i = heapSize / 2 - 1; i >= 0; --i) {
            minHeapify(a, i, heapSize);
        }
    }

    /**
     * 小值上浮
     * @param a
     * @param i
     * @param heapSize
     */
    static void minHeapify(int[] a, int i, int heapSize) {
        int l = i * 2 + 1, r = i * 2 + 2, smallest = i;
        if (l < heapSize && a[l] < a[smallest]) {
            smallest = l;
        }
        if (r < heapSize && a[r] < a[smallest]) {
            smallest = r;
        }
        if (smallest != i) {
            swap(a, i, smallest);
            minHeapify(a, smallest, heapSize);
        }
    }

    /**
     * 大值上浮
     * @param a
     * @param i
     * @param heapSize
     */
    static void maxHeapify(int[] a, int i, int heapSize) {
        int l = i * 2 + 1, r = i * 2 + 2, largest = i;
        if (l < heapSize && a[l] > a[largest]) {
            largest = l;
        }
        if (r < heapSize && a[r] > a[largest]) {
            largest = r;
        }
        if (largest != i) {
            swap(a, i, largest);
            maxHeapify(a, largest, heapSize);
        }
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}