大顶堆

#include <stdio.h>

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

int parent(int index) {
    return (index - 1) / 2;
}

int left(int index) {
    return index * 2 + 1;
}

int right(int index) {
    return (index + 1) * 2;
}

void max_heapify(int arr[], int size, int index) {
    int l = left(index), r = right(index), largest = index;
    if (l < size && arr[l] > arr[largest]) {
        largest = l;
    }
    if (r < size && arr[r] > arr[largest]) {
        largest = r;
    }
    if (largest != index) {
        swap(arr + largest, arr + index);
        max_heapify(arr, size, largest);
    }
}

void build_max_heap(int arr[], int size) {
    for (int i = (size - 1) / 2; i >= 0; --i) {
        max_heapify(arr, size, i);
    }
}

void heap_sort(int arr[], int size) {
    build_max_heap(arr, size);
    while (size > 1) {
        swap(arr, arr + --size);
        max_heapify(arr, size, 0);
    }
}

int heap_extract_max(int heap[], int *size) {
    swap(heap, heap + --*size);
    max_heapify(heap, *size, 0);
    return heap[*size];
}

void heap_increase_key(int heap[], int index, int key) {
    heap[index] = key;
    int p = index;
    while (p > 0 && heap[parent(p)] < heap[p]) {
        swap(heap + parent(p), heap + p);
        p = parent(p);
    }
}

void max_heap_insert(int heap[], int *size, int key) {
    heap_increase_key(heap, (*size)++, key);
}

int main() {
    int arr[100], size = 0;

    max_heap_insert(arr, &size, 3);
    max_heap_insert(arr, &size, 5);
    max_heap_insert(arr, &size, 1);
    max_heap_insert(arr, &size, 2);
    max_heap_insert(arr, &size, 4);
    while (size > 0) {
        printf("%d\t", heap_extract_max(arr, &size));
    }

    printf("\n");

    arr[0] = 3;
    arr[1] = 5;
    arr[2] = 1;
    arr[3] = 2;
    arr[4] = 4;
    size = 5;
    heap_sort(arr, size);
    for (int i = 0; i < size; ++i) {
        printf("%d\t", arr[i]);
    }
    return 0;
}