各种排序算法

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

#define LeftChild(i) (2 * (i) + 1)

/* 插入排序 */
void InsertionSort(int *A, int n)
{
    int j, p, tmp;
    for (p = 1; p < n; p++)
    {
        tmp = A[p];
        for (j = p; j > 0 && A[j-1] > tmp; j--)
            A[j] = A[j-1];
        A[j] = tmp;
    }
}

/* 希尔排序 */
void ShellSort(int *A, int n)
{
    int i, j, Increment;
    int tmp;

    for (Increment = n/2; Increment > 0; Increment /= 2)
        for (i = Increment; i < n; i++)
        {
            tmp = A[i];
            for (j = i; j >= Increment; j -= Increment)
                if (tmp < A[j - Increment])
                    A[j] = A[j - Increment];
                else
                    break;
            A[j] = tmp;
        }
}

/* 堆排序 */
void PercDown(int *A, int i, int N) /* 下滤操作 */
{
    int Child;
    int Tmp;

    for (Tmp = A[i]; LeftChild(i) < N; i = Child)
    {
        Child = LeftChild(i);
        if (Child != N-1 && A[Child + 1] > A[Child])
            Child++;
        if (Tmp < A[Child])
            A[i] = A[Child];
        else
            break;
    }
    A[i] = Tmp;
}

void HeapSort(int *A, int N)
{
    int i;

    for (i = N/2; i >= 0; i--)  /* BuildHeap */
        PercDown(A, i, N);
    for (i = N-1; i > 0; i--)
    {
        //Swap(&A[0], &A[i]);       /* DeleteMax*/
        int tmp = A[0];
        A[0] = A[i];
        A[i] = tmp;
        PercDown(A, 0, i);
    }
}

/* 归并排序 */
void Merge(int *A, int *TmpArray, int Lpos, int Rpos, int RightEnd)
{
    int i, LeftEnd, NumElements, TmpPos;

    LeftEnd = Rpos - 1;
    TmpPos = Lpos;
    NumElements = RightEnd - Lpos + 1;

    while (Lpos <= LeftEnd && Rpos <= RightEnd)
        if (A[Lpos] <= A[Rpos])
            TmpArray[TmpPos++] = A[Lpos++];
        else
            TmpArray[TmpPos++] = A[Rpos++];

    while (Lpos <= LeftEnd)     /* Copy rest of first half */
        TmpArray[TmpPos++] = A[Lpos++];
    while (Rpos <= RightEnd)    /* Copy rest of second half */
        TmpArray[TmpPos++] = A[Rpos++];

    /* Copy TmpArray back */
    for (i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpArray[RightEnd];
}

void MSort(int *A, int *TmpArray, int Left, int Right)
{
    int Center;

    if (Left < Right)
    {
        Center = (Left + Right) / 2;
        MSort(A, TmpArray, Left, Center);
        MSort(A, TmpArray, Center+1, Right);
        Merge(A, TmpArray, Left, Center+1, Right);
    }
}

void MergeSort(int *A, int n)
{
    int *TmpArray;
    TmpArray = malloc(n * sizeof(int));
    if (TmpArray != NULL)
    {
        MSort(A, TmpArray, 0, n-1);
        free(TmpArray);
    }
    else
        printf("No space for tmp array!!!\n");
}

/* 快速排序 */
void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int Median3(int *A, int Left, int Right)
{
    int Center = (Left + Right) / 2;

    if (A[Left] > A[Center])
        Swap(&A[Left], &A[Center]);
    if (A[Left] > A[Right])
        Swap(&A[Left], &A[Right]);
    if (A[Center] > A[Right])
        Swap(&A[Center], &A[Right]);

    Swap(&A[Center], &A[Right - 1]);
    return A[Right - 1];
}


#define Cutoff (3)
Qsort(int *A, int Left, int Right)
{
    int i, j, Pivot;

    if (Left + Cutoff <= Right)
    {
        Pivot = Median3(A, Left, Right);
        i = Left;
        j = Right - 1;
        for ( ; ; )
        {
            while (A[++i] < Pivot){}
            while (A[--j] > Pivot){}
            if (i < j)
                Swap(&A[i], &A[j]);
            else
                break;
        }
        Swap(&A[i], &A[Right - 1]); /* Restore pivot */

        Qsort(A, Left, i - 1);
        Qsort(A, i + 1, Right);
    }
    else
        InsertionSort(A, Right - Left + 1);
}

void QuickSort(int *A, int n)
{
    Qsort(A, 0, n-1);
}

int main()
{
    int i;
    printf("InsertionSort:\n");
    int A[] = {8, 34, 64, 51, 32, 21};
    InsertionSort(A, 6);
    for (i = 0; i < 6; i++)
        printf("%6d\n", A[i]);

    printf("ShellSort:\n");
    int B[] = {8, 34, 64, 51, 32, 21};
    ShellSort(B, 6);
    for (i = 0; i < 6; i++)
        printf("%6d\n", B[i]);

    printf("HeapSort:\n");
    int C[] = {53, 26, 41, 58, 59, 31, 97};
    HeapSort(C, 7);
    for (i = 0; i < 7; i++)
        printf("%6d\n", C[i]);

    printf("MergeSort:\n");
    int D[] = {13, 2, 28, 27, 26, 1, 15, 24};
    MergeSort(D, 8);
    for (i = 0; i < 8; i++)
        printf("%6d\n", D[i]);

    printf("QuickSort:\n");
    int E[] = {8, 1, 4, 9, 0, 3, 5, 2, 7, 6};
    QuickSort(E, 10);
    for (i = 0; i < 10; i++)
        printf("%d\n", E[i]);

    return 0;
}