排序

1.冒泡排序

void Bubble_Sort(ElementType A[], int N) 
{
    for(P=N-1;P>=0;P--)
    {
        flag = 0;
        for(i=0;i<P;i++)
        {
            if(A[i] > A[i+1])
            {
                Swap(A[i], A[i+1]);
                flag = 1;
            }
        }
        if(flag == 0)
            break;
    }
}

2.插入排序

void Insertion_Sort(ElementType A[], int N)
{
    for(p=1;p<N;p++)
    {
        Tmp = A[p];
        for(i=p;i>0&&A[i-1]>Tmp;i--)
            A[i] = A[i-1];
        A[i] = Tmp;
    }
}

3.希尔排序

void Shell_Sort(ElementType A[], int N)
{
    for(D=N/2;D>0;D/=2)
    {
        for(P=D;p<N;p++)
        {
            Tmp = A[p];
            for(i=p;i>=D&&A[i-D]>Tmp;i-=D)
                A[i] = A[i-D];
            A[i] = Tmp;
        }
    }
}

/*
    D可以取别的数：
    Hibbard增量序列：Dk = 2^k-1
    Sedgewick增量序列：9x4^i-9x2^i+1
*/

4.堆排序

/*
    MaxSort(ElementType A[], int i, int N)
    对A数组从i到0结点进行创建堆操作，N为A元素的个数
*/

void Heap_Sort(ElementType A[], int N)
{
    for(i=N/2-1;i>=0;i--)
        MaxSort(A,i,N);
    for(i=N-1;i>0;i--)
    {
        Swap(&A[0],&A[i]);
        MaxSort(A,0,i);
    }
}

5.归并排序

递归算法：
void Merge_Sort(ElementType A[],int N)
{
    ElementType *TmpA;
    TmpA = malloc(N*sizeof(ElementType));
    if(TmpA != NULL)
    {
        MSort(A,TmpA,0,N-1);
        free(TmpA);
    }
    else
        ERROR;
}

void MSort(ElementType A[],ElementType TmpA[], int L, int Rend)
{
    int center;
    if(L<Rend)
    {
        center = (L+Rend)/2;
        Msort(A,TmpA,L,center);
        Msort(A,TmpA,center+1,Rend);
        Merge(A,TmpA,L,center+1,Rend);
    }
}

void Merge(ElementType A[],ElementType TmpA[],int L,int R, int Rend)
{
    // L是A左半起始元素，R是右半起始元素，Rend是右边结束
    Lend = R-1;
    Tmp = L;
    NumElements = Rend -L +1;
    while(L<=Lend && R<=Rend)
    {
        if(A[L] <= A[R])
            TmpA[Tmp++] = A[L++];
        else
            TmpA[Tmp++] = A[R++];
    }
    while(L<=Lend)
        TmpA[Tmp++] = A[L++];
    while(L<=Rend)
        TmpA[Tmp++] = A[R++];
    for(i=0;i<NumElements;i++,Rend--)
        A[Rend] = TmpA[Rend];
}


非递归算法：
void Merge_Sort(ElementType A[], int N)
{
    ElementType *TmpA;
    int length = 1;
    TmpA = malloc(N*sizeof(ElementType));
    if(TmpA!=NULL)
    {
        while(length<n)
        {
            Merge_Pass(a, tema, n, length);
            length *= 2;
            Merge_Pass(tema, a, n, length);
            length *= 2;
        }
        free(TmpA);
    }
    else
        ERROR;
}

void Merge_Pass(ElementType A[], ElementType TmpA[], int N, int length)
{
    for(i=0;i<=N-2*length;i+=length*2)
        Merge1(A, TmpA, i, i+length, i+2*length-1);
    if(i+length<n)
        Merge1(A, TmpA, i, i+length, n-1);
    else
    {
        int j;
        for(j=i;j<n;j++)
        {
            TmpA[j] = A[j];
        }
    }
}

void Merge1(ElementType A[],ElementType TmpA[],int L,int R, int Rend)
{
    // L是A左半起始元素，R是右半起始元素，Rend是右边结束
    Lend = R-1;
    Tmp = L;
    while(L<=Lend && R<=Rend)
    {
        if(A[L] <= A[R])
            TmpA[Tmp++] = A[L++];
        else
            TmpA[Tmp++] = A[R++];
    }
    while(L<=Lend)
        TmpA[Tmp++] = A[L++];
    while(L<=Rend)
        TmpA[Tmp++] = A[R++];
}

6.快速排序

//当数据规模较小时还不如用插入排序，因为快速排序是递归算法

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

void QuickSort(ElementType A[], int Left, int Right)
{
    int cutoff = 100;
    if(cutoff<=Right-Left)
    {
        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]);
        QuickSort(A,Left,i-1);
        QuickSort(A,i+1,Right);
    }
    else
        Insertion_Sort(A+Left,Right-Left+1);
}

// 选取头、中、尾的中位数作为主元
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]);
    Swap(&A[Center], &A[Right-1]);
    return A[Right-1];
}

7.基数排序
桶排序：N>>M
N=4000个学生，成绩[0,100]即M=101,对学生按成绩排序，构造成绩数组（成绩101个选大小101），T=o(M)
基数排序：M>>N
N=10个整数，每个整数[0,999]，对整数排序，构造基数数组（十进制选大小10），根据各位、十位、百位（次位优先）进行排序

表排序
本质：要通过key进行排序，但是元素的“体积”过大，不适合直接swap，定义一个指针table，table的值的顺序就是相应index的元素的顺序。即A[table[0]]…A[ table[i]]就是排好序后的顺序。

如果这样排好序后，非要在物理位置上即非要swap排好序，那么有个结论：N个数字的排列由若干个独立的环组成，如图8个数字，由3个环组成，（eg：红环table[0]=3 -> table[3]=1 -> table[1]=5 -> table[5]=0 形成一个环）
所以swap时只要把环的第一个元素 (A[0]即f) 先拿出来，让后面的元素依次移位并设置table[i] = i，最后拿出来的元素放入空出来的位置（即A[5]，此时判断table[0] = 0,满足table[i] = i即一个环结束），再照样处理下个环，最终完成。