堆排序！！

算法思想

堆排序基于完全二叉树的堆数据结构，其中每个节点的值都大于或等于其子节点的值（最大堆），或者小于或等于其子节点的值（最小堆）。
堆排序的基本思想是

1. 首先将待排序的元素构建成一个最大堆
2. 然后将堆顶元素与堆的最后一个元素交换
3. 并将剩余的元素重新调整为最大堆。
4. 重复这个过程直到所有的元素都被排序。

maxHeapify函数

maxHeapify 函数：用于将以 curr 为根节点的子树堆化为最大堆。在堆化过程中，会比较当前节点与其子节点的值，并将较大的值交换到当前节点位置。该函数会在堆排序的过程中多次调用。

maxHeapify完整代码

void maxHeapify(vector<int> &heap, int curr, int end)
{
    int son = curr * 2;
    while (son <= end)                                        // 1
    {
        if (son + 1 <= end && heap[son + 1] > heap[son])      // 2
            son++;
        if (heap[son] > heap[curr])                           // 3
        {
            swap(heap[son], heap[curr]);                      // 4
            curr = son;                                       // 5
            son = son * 2;                                    // 6
        }
        else break;                                           // 7
    }

1. 当当前节点存在子节点时，进行循环操作
2. 如果右子节点存在且大于左子节点，则选择右子节点
3. 如果子节点的值大于当前节点的值
4. 交换子节点和当前节点的值
5. 更新当前节点的位置为子节点的位置
6. 继续向下遍历
7. 如果子节点的值不大于当前节点的值，则跳出循环

HeapSort函数

HeapSort 函数：将输入数组 a 当作堆来进行排序。

1. 首先，将数组堆化为最大堆，从最后一个非叶子节点开始，逐层向上进行堆化操作。
2. 然后，将堆顶元素（即最大值）与堆的最后一个元素交换，并将剩余元素重新堆化为最大堆，以此类推，直到所有元素都被排序。
3. 最后，返回排序后的数组。

HeapSort完整代码

int *HeapSort(vector<int> &a)
{
    vector<int> &heap = a;
    int root = 0;
    int length = a.size();
    
    for (int i = length / 2; i > root - 1; i--)
        maxHeapify(heap, i, length - 1);               // 1
    for (int i = length - 1; i > root; i--)
    {
        swap(heap[root], heap[i]);                     // 2
        maxHeapify(heap, root, i - 1);
    }
    return &a[0];                                     // 3
}

1. 构建最大堆，从非叶子节点开始向上进行堆化操作
2. 交换堆顶元素与堆的最后一个元素，并进行堆化操作，每次将最大值移到数组末尾
3. 返回排序后的数组首地址

问题描述

给你一个整数数组 nums，请你将该数组升序排列。
https://leetcode.cn/problems/sort-an-array/description/

完整代码

class Solution {
    void maxHeapify(vector<int> &heap, int curr, int end)
    {
        int son = curr * 2;
        while (son <= end)
        {
            if (son + 1 <= end && heap[son + 1] > heap[son])
                son++;
            if (heap[son] > heap[curr])
            {
                swap(heap[son], heap[curr]);
                curr = son;
                son = son * 2;
            }
            else break;
        }
    }
    int *HeapSort(vector<int> &a)
    {
        vector<int> &heap = a;
        int root = 0;
        int length = a.size();
        for (int i = length / 2; i > root - 1; i--)
            maxHeapify(heap, i, length - 1);
        for (int i = length - 1; i > root; i--)
        {
            swap(heap[root], heap[i]);
            maxHeapify(heap, root, i - 1);
        }
        return &a[0];
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        HeapSort(nums);
        return nums;
    }
};

如果可以的话希望大家可以自己手画一遍模拟一下这个过程哦~