堆排序

/*将“堆”看成一棵完全二叉树，用数组存放元素。
 *数组从下标为1开始存放元素。
 *堆排序是一种“原地”排序算法，其操作均在原数组A[]中进行。
 */
#include <iostream>
using namespace std;

void display(int A[], int arr_size); //输出函数
void heapsort(int A[], int arr_size); //堆排序函数

int main() {
    int A[] = {0, 4, 1, 3, 2, 16, 9, 10, 14, 8, 7};

    display(A, 10);
    heapsort(A, 10);
    display(A, 10);

    return 0;
}

void display(int A[], int arr_size) {
    for(int i = 1; i <= arr_size; i++)
        cout << A[i] << " ";
    cout << endl;
}

void exchange(int &a, int &b) {
    int t = a;
    a = b;
    b = t;
}

/*返回i结点的左儿子的下标*/
int left(int i) {
    return 2 * i;
}

/*返回i结点的右儿子的下标*/
int right(int i) {
    return 2 * i + 1;
}

/*保持最大堆的性质。调用max_heapify时，假定left(i),right(i)两棵子树均为最大堆了，调用max_heapify后,使得以i为根的树成为最大堆*/
void max_heapify(int A[], int heap_size, int i) {
    int l = left(i);
    int r = right(i);
    int largestIndex;
    if(l <= heap_size && A[l] > A[i])
        largestIndex = l;
    else
        largestIndex = i;

    if(r <= heap_size && A[r] > A[largestIndex])
        largestIndex = r;

    if(largestIndex != i) {
        exchange(A[i], A[largestIndex]);
        max_heapify(A, heap_size, largestIndex);
    }
}

/*建堆*/
void build_max_heap(int A[], int arr_size) {
    int heap_size = arr_size;
    for(int i = arr_size / 2; i >= 1; i--) {
        max_heapify(A, heap_size, i);
    }
}

/*利用堆对一组数行排序*/
void heapsort(int A[], int arr_size) {
    build_max_heap(A, arr_size);
    int heap_size = arr_size;
    for(int i = arr_size; i >= 2; i--) {
        exchange(A[1], A[i]);
        heap_size--;
        max_heapify(A, heap_size, 1);
    }
}