堆排序代码

大根堆

#include <stdio.h>

// 大根堆：

// 建立大根堆
void maxHeapify(int arr[], int n, int i)
{
    int largest = i;       // 初始化最大值的索引为i
    int left = 2 * i + 1;  // 左子节点的索引
    int right = 2 * i + 2; // 右子节点的索引

    // 如果左子节点比根节点大，则更新最大值的索引
    if (left < n && arr[left] > arr[largest])
    {
        largest = left;
    }

    // 如果右子节点比当前最大值大，则更新最大值的索引
    if (right < n && arr[right] > arr[largest])
    {
        largest = right;
    }

    // 如果最大值的索引不等于i，说明发生了交换
    if (largest != i)
    {
        // 交换arr[i]和arr[largest]
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        // 递归调用maxHeapify，确保子树也满足大根堆性质
        maxHeapify(arr, n, largest);
    }
}

// 建立大根堆的函数
void buildMaxHeap(int arr[], int n)
{
    // 从最后一个非叶子节点开始，依次向上调用maxHeapify
    for (int i = n / 2 - 1; i >= 0; i--)
    {
        maxHeapify(arr, n, i);
    }
}

// 堆排序算法
void heapSort(int arr[], int n)
{
    // 首先建立大根堆
    buildMaxHeap(arr, n);
    // 依次将堆顶元素（最大值）与末尾元素交换，并调用maxHeapify维护大根堆性质
    for (int i = n - 1; i > 0; i--)
    {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        maxHeapify(arr, i, 0);
    }
}

小根堆

// 小根堆

// 建立小根堆
void minHeapify(int arr[], int n, int i)
{
    int smallest = i;      // 初始化最小值的索引为i
    int left = 2 * i + 1;  // 左子节点的索引
    int right = 2 * i + 2; // 右子节点的索引

    // 如果左子节点比根节点小，则更新最小值的索引
    if (left < n && arr[left] < arr[smallest])
    {
        smallest = left;
    }

    // 如果右子节点比当前最小值小，则更新最小值的索引
    if (right < n && arr[right] < arr[smallest])
    {
        smallest = right;
    }

    // 如果最小值的索引不等于i，说明发生了交换
    if (smallest != i)
    {
        // 交换arr[i]和arr[smallest]
        int temp = arr[i];
        arr[i] = arr[smallest];
        arr[smallest] = temp;
        // 递归调用minHeapify，确保子树也满足小根堆性质
        minHeapify(arr, n, smallest);
    }
}

// 建立小根堆的函数
void buildMinHeap(int arr[], int n)
{
    // 从最后一个非叶子节点开始，依次向上调用minHeapify
    for (int i = n / 2 - 1; i >= 0; i--)
    {
        minHeapify(arr, n, i);
    }
}

// 堆排序算法
void heapSort(int arr[], int n)
{
    // 首先建立小根堆
    buildMinHeap(arr, n);
    // 依次将堆顶元素（最小值）与末尾元素交换，并调用minHeapify维护小根堆性质
    for (int i = n - 1; i > 0; i--)
    {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        minHeapify(arr, i, 0);
    }
}