一般来说，这三者的时间复杂度O(NlogN)，空间复杂度O(n)
优化后，空间复杂度均可为O(1)，如下文中的快排和堆排序
归并排序是稳定排序算法，其余两者不是稳定排序
快排的最差时间复杂度为O(N^2),平均为O(NlogN)
归并和堆的最差、平均时间复杂度为O(NlogN)
T(n) = 2T(n/2)+cn

//归并排序的特点：分治的应用。需要准确并深入的理解分治的思想，分而治之

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

void Merge(int* a, int low, int mid, int high)
{
    int i = low, j = mid+1, size = 0;
    int tmpa[high-low+1] ;
    for (int k = 0; k < high-low+1; ++k){
        if(i > mid) tmpa[size++] = a[j++];
        else if(j > high) tmpa[size++] = a[i++];
        else if(a[i] <= a[j]) tmpa[size++] = a[i++];
        else tmpa[size++] = a[j++];
    }

    for(i = 0; i < size; i++)
        a[low+i] = tmpa[i];
}

void MergeSort(int* a, int low, int high)
{
    if(low >= high) return;

    int mid = (low + high) / 2;
    MergeSort(a, low, mid);
    MergeSort(a, mid+1, high);
    Merge(a, low, mid, high);
}

int Partition2(int* a, int l, int r)
{
    if(l >= r) return l;
    int len = r-l+1, tmp = a[l];
    int i = 0, j = len, k = 0;
    int atmp[len];

    for (k = l+1; k <= r; ++k){
        if (a[k] >= tmp) atmp[--j] = a[k];
        else atmp[i++] = a[k];
    }
    atmp[i] = tmp;
    for (k = 0; k < len; ++k){
        a[l+k] = atmp[k];
    }
    return l+i;
}

int Partition(int* a, int l, int r)
{
    int i = l, j = r, tmp = a[l];

    while(i < j){
        while((i < j) && (a[j] >= tmp)) j--;
        if (i < j){
            a[i++] = a[j];
        }
        while((i < j) && (a[i] < tmp)) i++;
        if (i < j){
            a[j--] = a[i];
        }
    }

    a[i] = tmp;
    return i;
}

void QuickSort(int* a, int low, int high)
{
    if(low >= high) return;

    int mid = Partition2(a, low, high);
    QuickSort(a, low, mid-1);
    QuickSort(a, mid+1, high);
}

# @arr:顺序存储二叉堆的数组
# @s: 调整的起始非叶节点
# @t: 二叉堆总长度，或总结点数
# @Description:将以s节点为根的子二叉树，调整为二叉堆
def heap_adjust(arr, s, size):
    child = 2*s + 1  # s的左子节点
    while child < size:
        if (child+1 < size) and (arr[child] < arr[child+1]): # 左右俩中，找值大的孩子
            child += 1
        if arr[s] > arr[child]: # 孩子比父亲小，说明无需调整
            break

        tmp = arr[child] # 孩子比父亲大，则交换父亲和大孩子，使其符合二叉堆性质
        arr[child] = arr[s]
        arr[s] = tmp
        
        s = child # 这个孩子刚和父亲交换被修改过，所以以其为根的二叉堆要重新调整
        child = 2*s + 1

# @arr, 数组大小为N, 从0开始到N-1, heap也从零开始
# 最后一个非叶子节点序号为 N/2 -1
def heap_sort(arr):
    # 初始化堆，将原始数组，调整为大顶堆，O(N)
    for i in range(len(arr)/2 - 1, -1, -1): # 从最后一个非叶子节点开始调整
        heap_adjust(arr, i, len(arr))

    for i in range(len(arr)-1, 0, -1):
        # 将堆顶元素(大顶堆，故此为最大值)与最后一个元素交换，然后重新调整堆
        tmp = arr[i]
        arr[i] = arr[0]
        arr[0] = tmp
        heap_adjust(arr, 0, i)

int main()
{
    int arr[]={3, 4, 5, 6, 24, 13, 26, 1, 2, 27, 38, 15, 15};
    int size = sizeof(arr) / sizeof(int);

    //MergeSort(arr, 0, size-1);
    QuickSort(arr, 0, size-1);

    for(int i = 0; i < size; i++){
        printf("%3d ", arr[i]);
    }
    printf("\n");
    return 0;
}