[数据结构与算法] : 排序

/* This file contains a collection of sorting routines */
#include <stdio.h>
#include <stdlib.h>
#include "fatal.h"

typedef int ElementType;

void Swap(ElementType *Lhs, ElementType *Rhs)
{
    ElementType Tmp;
    Tmp = *Lhs;
    *Lhs = *Rhs;
    *Rhs = Tmp;
}

void PrintArray(ElementType A[], int N)
{
    int i;
    for(i = 0; i < N; ++i)
        printf("%d ", A[i]);
    printf("\n");
}

void InsertionSort(ElementType A[], int N)
{
    int i, j;
    ElementType Tmp;

    for(i = 1; i < N; ++i)
    {
        Tmp = A[i];
        for(j = i; j >= 1 && A[j-1] > Tmp; --j)
            A[j] = A[j-1];
        A[j] = Tmp;
    }
}

void ShellSort(ElementType A[], int N)
{
    int i, j, Increment;
    ElementType Tmp;

    for(Increment = N/2; Increment > 0; Increment /=2)
    {
        for(i = Increment; i < N; ++i)
        {
            Tmp = A[i];
            for(j = i; j >= Increment && A[j-Increment] > Tmp; j -= Increment)
                A[j] = A[j-Increment];
            A[j] = Tmp;
        }
    }
}

// 简单选择排序
void SelectSort(ElementType A[], int N)
{
    int i, j;
    int MinIdx;

    for(i = 0; i < N-1; ++i) // N-1次即可完成排序
    {
        MinIdx = i;
        for(j = i+1; j < N; ++j) // 在[i+1, N)范围内查找最小值
        {
            if(A[j] < A[MinIdx])
                MinIdx = j;
        }
        if(i != MinIdx)
            Swap(&A[i], &A[MinIdx]);
    }
}

// 简单选择排序的改进: 在查找最小值的同时，可以查找出最大值,
// 最小值和第一个元素交换，最大值和最后一个元素交换。
void SelectSortII(ElementType A[], int N)
{
    int i, j;
    int MinIdx, MaxIdx;

    for(i = 0; i < N/2; ++i) // 一次排好最小值和最大值, 因此N/2次循环可以排好整个序列
    {
        MinIdx = i;
        MaxIdx = N-i-1;
        for(j = i; j < N-i; ++j) // 在[i, N-i)范围内查找最小值和最大值, 注意不能从i+1开始
        {
            if(A[j] < A[MinIdx])
                MinIdx = j;
            if(A[j] > A[MaxIdx])
                MaxIdx = j;
        }

        if(MinIdx != i)
            Swap(&A[MinIdx], &A[i]);
        if(MaxIdx != N-i-1)
            Swap(&A[MaxIdx], &A[N-i-1]);
    }
}

// 第6.3节讲的二叉堆左儿子为2*i, 右儿子为2*i+1, 下标为0的元素用于标记
// 堆排序中不使用头节点, 因此左儿子为2*i+1, 右儿子为2*i+2
#define LeftChild(i) ( 2 * (i) + 1 )

void PercDown(ElementType A[], int i, int N)
{
    int Child;
    ElementType 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(ElementType A[], int N)
{
    int i;

    for(i = N/2; i >= 0; --i) /* BuildHeap */
        PercDown(A, i, N);

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

// N个元素需要N-1趟才可以排好, i的取值为[0, N-1);
// 每趟排序都会确定最后一个元素, 因此j的上界为N-i,
// 考虑到循环内部使用了j+1, 因此上界应该为N-i-1,
// 每趟比较从第0个元素开始, 下界为0
void BubbleSort(ElementType A[], int N)
{
    int i, j;

    for(i = 0; i < N-1; ++i)
    {
        for(j = 0; j < N-i-1; ++j)
        {
            if(A[j] > A[j+1])
                Swap(&A[j], &A[j+1]);
        }
        PrintArray(A, 7);
    }
}

/* Lpos = start of left half, Rpos = start of right half */
void Merge(ElementType A[], ElementType TmpArray[],
           int Lpos, int Rpos, int RightEnd)
{
    int i, LeftEnd, NumElements, TmpPos;

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

    /* main loop */
    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(ElementType A[], ElementType 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);
    }
}

// MergeSort为递归例程MSort的驱动程序
void MergeSort(ElementType A[], int N)
{
    ElementType *TmpArray;

    TmpArray = (ElementType *)malloc(N * sizeof(ElementType));
    if(TmpArray != NULL)
    {
        MSort(A, TmpArray, 0, N-1); // 注意是N-1
        free(TmpArray);
    }
    else
        FatalError("Out of space!");
}

/* Return median of Left, Center, and Right */
/* Order these and hide the pivot */
ElementType Median3(ElementType 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]);

    /* Invariant: A[ Left ] <= A[ Center ] <= A[ Right ] */

    Swap(&A[Center], &A[Right-1]); /* Hide pivot */
    return A[Right-1];             /* Return pivot */
}

#define Cutoff (3)

void Qsort(ElementType A[], int Left, int Right)
{
    int i, j;
    ElementType 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 /* Do an insertion sort on the subarray */
        InsertionSort(A + Left, Right - Left + 1);
}

/*
// 测试通过, 选取最后一个元素为枢纽元的排序方法
void Qsort(ElementType A[], int Left, int Right)
{
    int i, j;
    ElementType Pivot;

    if(Left < Right) // 这里用 < 或者 <=都可以
    {
        Pivot = A[Right]; // 选择最右边的元素为枢纽元
        i = Left-1, j = Right; // 注意这里i= Left - 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]);

        Qsort(A, Left, i - 1);
        Qsort(A, i + 1, Right);
    }
}
*/

void QuickSort(ElementType A[], int N)
{
    Qsort(A, 0, N-1);
}

/* Places the kth smallest element in the kth position */
/* Because arrays start at 0, this will be index k-1 */
void Qselect(ElementType A[], int k, int Left, int Right)
{
    int i, j;
    ElementType 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 */

        if(k <= i)
            Qselect(A, k, Left, i - 1);
        else
            Qselect(A, k, i + 1, Right);
    }
    else /* Do an insertion sort on the subarray */
        InsertionSort(A + Left, Right - Left + 1);
}

/* ROUTINES TO TEST THE SORTS */
void Permute(ElementType A[], int N)
{
    int i;

    for(i = 0; i < N; ++i)
        A[i] = i;
    for(i = 1; i < N; ++i)
        Swap(&A[i], &A[rand() % (i + 1)]);
}

void CheckSort(ElementType A[], int N)
{
    int i;

    for(i = 0; i < N; ++i)
        if(A[i] != i)
            printf("Sort fails: %d\n", i);
    printf("Check completed\n");
}

void Copy(ElementType Lhs[], const ElementType Rhs[], int N)
{
    int i;
    for(i = 0; i < N; ++i)
        Lhs[i] = Rhs[i];
}

#define MaxSize 7000
int Arr1[MaxSize];
int Arr2[MaxSize];

int main()
{
    int i;
    for(i = 0; i < 10; ++i)
    {
        Permute(Arr2, MaxSize); // 生成一个随机数组

        Copy(Arr1, Arr2, MaxSize);
        InsertionSort(Arr1, MaxSize);
        CheckSort(Arr1, MaxSize);

        Copy(Arr1, Arr2, MaxSize);
        ShellSort(Arr1, MaxSize);
        CheckSort(Arr1, MaxSize);

        Copy(Arr1, Arr2, MaxSize);
        HeapSort(Arr1, MaxSize);
        CheckSort(Arr1, MaxSize);

        Copy(Arr1, Arr2, MaxSize);
        MergeSort(Arr1, MaxSize);
        CheckSort(Arr1, MaxSize);

        Copy(Arr1, Arr2, MaxSize);
        QuickSort(Arr1, MaxSize);
        CheckSort(Arr1, MaxSize);

        Copy(Arr1, Arr2, MaxSize);
        Qselect(Arr1, MaxSize / 2 + 1 + i, 0, MaxSize - 1);
        if(Arr1[MaxSize / 2 + 1 + i] != MaxSize / 2 + 1 + i)
             printf("Select error: %d %d\n", MaxSize / 2 + 1 + i, Arr1[MaxSize / 2 + 1 + i]);
         else
             printf("Select works\n");
    }
    return 0;
}