🏆 作者简介，愚公搬代码 🏆《头衔》：华为云特约编辑，华为云云享专家，华为开发者专家，华为产品云测专家，CSDN博客专家，阿里云专家博主，腾讯云优秀博主，掘金优秀博主，51CTO博客专家等。 🏆《近期荣誉》：2022年CSDN博客之星TOP2，2022年华为云十佳博主等。

🏆《博客内容》：.NET、Java、Python、Go、Node、前端、IOS、Android、鸿蒙、Linux、物联网、网络安全、大数据、人工智能、U3D游戏、小程序等相关领域知识。

🏆🎉欢迎 👍点赞✍评论⭐收藏

🚀前言

排序算法是一种将一组数据按照特定的规则进行排列的方法。排序算法通常用于对数据的处理，使得数据能够更容易地被查找、比较和分析。

下面是常见的11种排序算法：

1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前面的元素大于后面的元素，就交换这两个元素的位置。时间复杂度为O(n^2)。
2. 选择排序（Selection Sort）：在未排序的数据中找到最小（大）的元素，放置在已排序的数据末尾。时间复杂度为O(n^2)。
3. 插入排序（Insertion Sort）：将未排序的元素插入到已排序的序列中，时间复杂度为O(n^2)。
4. 希尔排序（Shell Sort）：希尔排序是插入排序的一种改进，它将原序列分割成若干个子序列，对每个子序列进行插入排序，最后对整个序列进行插入排序。时间复杂度为O(nlogn)。
5. 二路归并排序（Merge Sort）：二路归并排序是指将一个序列分成两个子序列，分别对两个子序列进行归并排序，然后将排序好的两个子序列合并成一个有序序列的过程。这种排序思想采用了分治算法的思想，排序效率较高，时间复杂度为 O(nlogn)。
6. 快速排序（Quick Sort）：选择一个基准元素，将大于基准元素的数放在一边，小于基准元素的数放在另一边，递归执行该过程，最后得到有序序列。时间复杂度为O(nlogn)。
7. 堆排序（Heap Sort）：将序列转换为一个大根堆，每次将堆顶元素与堆底元素交换，然后将剩余元素重新构建堆，重复执行该过程，最后得到有序序列。时间复杂度为O(nlogn)。
8. 计数排序（Counting Sort）：统计小于等于每个元素的个数，再依次计算出每个元素在有序序列中的位置。时间复杂度为O(n+k)，其中k为最大元素值。
9. 桶排序（Bucket Sort）：将元素分到多个桶中，对每个桶进行排序，最后将所有桶中的元素按顺序合并起来。时间复杂度为O(n)。
10. 基数排序（Radix Sort）：按照低位到高位的顺序对元素进行排序，依次排序后得到有序序列。时间复杂度为O(dn)，其中d为元素的位数。
11. 多路归并排序：多路归并排序是指将一个序列分成多个子序列，然后对每个子序列进行排序，最后将排好序的子序列合并成一个有序序列的过程。多路归并排序的时间复杂度不仅取决于序列长度，还取决于子序列个数。多路归并排序的优点是可以对比二路归并排序更加高效地利用计算机的多核心处理能力，因此在大规模数据处理中有广泛的应用。

🚀一、堆排序

🔎1.基本思想

堆排序的基本思想是利用堆的性质来进行排序。堆是一种完全二叉树，具有两个性质：

1. 堆的父节点的值总是大于或等于（小于或等于）其子节点的值。
2. 堆是一棵完全二叉树。

堆排序的过程如下：

1. 构建一个最大堆或最小堆。
2. 将堆顶元素与堆尾元素交换。
3. 对除去已排序的元素，剩余元素重新构建最大堆或最小堆。
4. 重复步骤2和3直到所有的元素都已排序。

构建堆的时间复杂度为O(n)，每次交换堆顶元素和堆尾元素的时间复杂度为O(1)，重复步骤2和3的时间复杂度为O(nlogn)。因此堆排序的时间复杂度为O(nlogn)，是一种比较高效的排序算法。

🔎2.复杂度分析

堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。

堆排序的核心是堆的建立和调整过程，堆排序采用了完全二叉树的性质，利用堆这种数据结构来实现排序。具体实现过程如下：

1. 建立大根堆或小根堆（根据排序要求来确定）。
2. 将堆顶元素与堆底元素交换，将最大或最小元素放到数组的最后位置。
3. 调整堆，保持堆的性质，重复第2步，直到排序完成。

因为每次需要将堆顶元素与堆底元素交换，并对其进行调整，所以时间复杂度为O(nlogn)。空间复杂度由于堆是在原数组上建立的，因此空间复杂度为O(1)。

堆排序适用于数据量较大的排序，但不适用于数据量较小的排序，因为堆排序的常数因子较大，且在数据量较小的情况下，其他排序算法的优势更加明显。

🔎3.应用场景

堆排序的主要应用场景是在需要对大量数据进行排序的场合，特别是对于需要对数据进行实时处理的场合。以下是堆排序的一些应用场景：

1. 数据库中的排序：在数据库中对大量数据进行排序时，堆排序是一种非常有效的算法。
2. 操作系统中的调度：在操作系统中，需要对进程进行调度。为了选择下一个要执行的进程，需要根据优先级对它们进行排序。堆排序可以帮助操作系统进行进程调度。
3. 网络搜索引擎中的排序：对于搜索引擎而言，需要对大量网页进行排序。堆排序可以有效地进行这样的排序。
4. 游戏中的AI：在游戏中，需要对AI进行排序，以确定下一个要执行的AI。堆排序可以帮助游戏中的AI进行排序。
5. 物流和运输：在物流和运输领域，需要对货物进行排序，以便更好地规划运输路线。堆排序可以帮助进行这种排序。

总之，堆排序是一种非常高效的算法，可以应用于需要对大量数据进行排序的场合，特别是对于需要实时处理数据的场合。

🔎4.示例

/// <summary>
/// 堆排序
/// </summary>
public class Program {

    public static void Main(string[] args) {
        int[] array = { 43, 69, 11, 72, 28, 21, 56, 80, 48, 94, 32, 8 };

        HeapSort(array);
        ShowSord(array);

        Console.ReadKey();
    }

    private static void ShowSord(int[] array) {
        foreach (var num in array) {
            Console.Write($"{num} ");
        }
        Console.WriteLine();
    }

    private static void HeapSort(int[] array) {
        MaxHeap(array);
        for (int i = array.Length - 1; i > 0; i--) {
            Swap(ref array[0], ref array[i]);
            Heapify(array, 0, i);
        }
    }

    private static void MaxHeap(int[] array) {
        for (int i = array.Length / 2 - 1; i >= 0; i--) {
            Heapify(array, i, array.Length);
        }
    }

    private static void Heapify(int[] array, int index, int size) {
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        int large = index;

        if (left < size && array[left] > array[large]) {
            large = left;
        }
        if (right < size && array[right] > array[large]) {
            large = right;
        }
        if (index != large) {
            Swap(ref array[index], ref array[large]);
            Heapify(array, large, size);
        }
    }

    private static void Swap(ref int first, ref int second) {
        int t = first;
        first = second;
        second = t;
    }

}

我正在参与2023腾讯技术创作特训营第三期有奖征文，组队打卡瓜分大奖！