堆排序

1. 建树
   
2. 排序
   
3. 代码 c实现

#include <stdio.h>
#include <stdlib.h>
#include "HeapSort.h"

#undef LEFTINDEX
#define LEFTINDEX(i) (((i) << 1) + 1)

#undef RIGHTINDEX
#define RIGHTINDEX(i) (((i) << 1) + 2)

#undef FATHERINDEX
#define FATHERINDEX(i) (((i-1) >> 1))

#undef ISRIGHTNODE
#define ISRIGHTNODE(i) ((((i) >> 1) << 1) == (i) ? 1 : 0)

#undef HASCHILD
#define HASCHILD(i, len) (LEFTINDEX(i) > (len - 1) ? 0 : 1)

#undef MAX
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// 返回0表示没有进行交换, 返回非零表示进行了交换值为交换的子节点的index
int MaxToFather(int* data, int right, int father, int left) {
    if (data[left] > data[father] && data[left] > data[right]) {
        int t0 = data[father];
        data[father] = data[left];
        data[left] = t0;
        return left;
    }
    else if (data[right] > data[father] && data[right] > data[left]) {
        int t0 = data[father];
        data[father] = data[right];
        data[right] = t0;
        return right;
    }
    return 0;
}

void ForwardBuild(int* data, int index, int length) {
    if (!HASCHILD(index, length)) return;

    int father_index = index;
    int left_index = LEFTINDEX(father_index);
    if (RIGHTINDEX(index) > (length - 1)) { //没有右节点
        if (data[left_index] > data[father_index]) {
            int t0 = data[father_index];
            data[father_index] = data[left_index];
            data[left_index] = t0;
        }
        return;
    }
    else {  //有右节点
        int right_index = RIGHTINDEX(index);
        int index = MaxToFather(data, right_index, father_index, left_index);
        if (index != 0) {
            ForwardBuild(data, index, length);
        }
    }

}

void dumpData(int *data, int length) {
    for (int i = 0; i < length; ++i) {
        printf("%d, ", data[i]);
    }
    printf("\n");
}

void BackBuild(int* data, int length) {
    int endIndex = length - 1;
    int offset = 0;
    if (ISRIGHTNODE(endIndex)) {
        offset = endIndex - 2;
        int right_index = endIndex;
        int father_index = FATHERINDEX(endIndex);
        int left_index = LEFTINDEX(father_index);
        MaxToFather(data, right_index, father_index, left_index);
    }else {
        offset = endIndex - 1;
        int father_index = FATHERINDEX(endIndex);
        //data[father_index] = MAX(data[father_index], data[endIndex]);
        if (data[father_index] < data[endIndex]) {
            int t0 = data[father_index];
            data[father_index] = data[endIndex];
            data[endIndex] = t0;
        }
    }
    //dumpData(data, length);
    for (int l = offset; l > 0; l -= 2) {        
        int right_index = l;
        int father_index = FATHERINDEX(right_index);
        int left_index = LEFTINDEX(father_index);
        int index = MaxToFather(data, right_index, father_index, left_index);
        if (index != 0) {
            ForwardBuild(data, index, length);
        }
        //dumpData(data, length);
    }
}

void BuildHeap(int* data, int length) {
    BackBuild(data, length);
}

void RebuildHeap(int* data, int index, int length) {

    if (HASCHILD(index, length)) {
        if (RIGHTINDEX(index) > length - 1) {  //没有右节点
            int left_index = LEFTINDEX(index);
            data[index] = data[left_index];

            RebuildHeap(data, left_index, length);
        }
        else {  //有右节点
            int left_index = LEFTINDEX(index);
            int right_index = RIGHTINDEX(index);
            if (data[left_index] > data[right_index]) {
                data[index] = data[left_index];
                RebuildHeap(data, left_index, length);
            }
            else {
                data[index] = data[right_index];
                RebuildHeap(data, right_index, length);
            }
        }
    }
    else {
        data[index] = data[length - 1];
        return;
    }

}


void HeapSort(int* data, int length) {
    int offset = 1;
    for (int i = 0; i < length - 1; ++i) {
        int t = data[0];

        RebuildHeap(data, 0, length - offset + 1);
        data[length - offset] = t;

        dumpData(data, length);
        offset++;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include "HeapSort.h"

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