每天学习一个小算法：堆排序

堆排序

算法原理
一、适用场景
二、复杂度分析
- 1.时间复杂度
- 2.空间复杂度
三、代码实现
总结

算法原理

堆排序利用二叉堆（大顶堆）的特性实现排序：

建堆：把数组构建成一个大顶堆，堆顶为最大值。
交换：将堆顶与末尾元素交换，固定最大值。
堆化：对剩余元素重新调整为堆，重复直到全部有序。

一、适用场景

大数据量排序，性能稳定 O(n log n)
内存紧张场景（无需额外空间）
求 Top K 问题（如最大/最小前 K 个）
不要求稳定性的工业级排序场景
嵌入式、底层系统优先选择

二、复杂度分析

1.时间复杂度

最好时间复杂度：O(n log n)
平均时间复杂度：O(n log n)
最坏时间复杂度：O(n log n)

2.空间复杂度

空间复杂度：O(1)

三、代码实现

1、Python实现

python 复制代码

# 堆排序 Python 实现
def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[l] > arr[largest]:
        largest = l
    if r < n and arr[r] > arr[largest]:
        largest = r

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n//2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr

2、Java实现

java 复制代码

// 堆排序 Java 实现
public static void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest]) largest = l;
    if (r < n && arr[r] > arr[largest]) largest = r;

    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

public static void heapSort(int arr[]) {
    int n = arr.length;
    for (int i = n/2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n-1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

3、C语言实现

c 复制代码

// 堆排序 C 语言实现
void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;

    if (l < n && arr[l] > arr[largest]) largest = l;
    if (r < n && arr[r] > arr[largest]) largest = r;

    if (largest != i) {
        int temp = arr[i];
        arr[i] = arr[largest];
        arr[largest] = temp;
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    for (int i = n - 1; i > 0; i--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapify(arr, i, 0);
    }
}

总结

记录自己的快乐学习日志，也祝贺观看到这的小伙伴早日学有所成，财富自由💰💰。

记得点赞👍、收藏👋呀！！！