死磕排序算法之堆排序

最新推荐文章于 2025-08-07 21:26:15 发布

原创最新推荐文章于 2025-08-07 21:26:15 发布 · 159 阅读

1 ·

CC 4.0 BY-SA版权

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

2 篇文章

订阅专栏

本文详细介绍了堆排序算法，包括堆的概念、堆排序的工作原理及其具体实现步骤。通过实例演示了如何将一个数组转换成最大堆，并逐步调整得到有序序列。同时提供了完整的Java实现代码。

介绍

堆排序就是利用堆这种数据结构来实现的一种排序算法，平均时间复杂度为O(nlogn),空间复杂度为O(1)

堆

堆是一种完全二叉树，即除了最底层，其他层的节点都被元素填满，且最底层尽可能地从左到右填入

堆有堆序性，每个结点的值都大于或等于其左右孩子的值，称为大顶堆，每个结点的值都小于或等于其左右孩子的值，称为小顶堆。

图形演示

heapsort

这里Youtobe上有个讲heap sort的两份钟视频，讲的挺不错,我将它下载下来传到优酷上面了，名叫堆排序

算法实例分析

假设一个数组为[1,12,9,5,6,10]

heap

将其变为最大堆,过后将堆顶元素与堆尾元素进行互换，互换后重新调整堆结构。后续过程，继续交换，调整，最后得到有序序列，下面是图形演示。

heap sort

算法源代码

package com.pjmike.sort;

import java.util.Arrays;

/**
 * 堆排序
 *
 * @author pjmike
 * @create 2018-08-06 11:14
 */
public class HeapSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2, 3, 2, 5, 8, 4, 9, 0};
        create(arr);
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 建立堆
     *
     * @param arr
     */
    static void create(int[] arr) {
        int n = arr.length;
        System.out.println("n: " + n);
        for (int i = n / 2 - 1; i >= 0; i--) {
            System.out.println("i值：" + i);
            heapify(arr, n, i);
        }
    }

    /**
     * 堆排序
     *
     * @param arr
     */
    static void heapSort(int[] arr) {
        int n = arr.length;
        for (int i = n - 1; i >= 0; i--) {
            //交换堆顶和堆尾元素
            swap(arr, 0, i);
            //此时堆的Length为i,将已调整的元素抛开在外，重新对堆进行调整使其成为最大堆
            heapify(arr, i, 0);
        }
    }

    /**
     * 建立最大堆
     *
     * @param arr
     * @param i
     */
    static void heapify(int[] arr, int n, int i) {
        int largest = i;
        //左子树编号
        int left = 2 * i + 1;
        //右子树编号
        int right = 2 * i + 2;
        //如果左子树的值比结点的值大，就交换左子树和结点的值
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }
        //如果右子树的值比此时的arr[largest]值大，就相互交换值
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }
        //如果largest还是==i,说明父节点的值比两边子树的值都大
        if (largest != i) {
            swap(arr, largest, i);
            //递归进行下一轮
            heapify(arr, n, largest);
        }
    }

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