Sort

一个顺序的数据结构，这个结构可以用于排列用的顺序表结构

#define MAXNSIZE 10
typedef struct{
    int r[MAXNSIZE+1];//r[0]作为哨兵结点或临时变量
    int length;
}SqList;

void swap(SqList *L,int i,int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}

BubbleSort 最简单的排序 时间复杂度O(N^2)

void BubbleSort(SqList *L)
{
    int i,j;
    for(i=1;i<L->length;i++)
    {
        for(j=L->length;j>i;j--)
        {
            if(L->r[j] < L->r[j-1])
            {
                swap(L,j,j-1);
            }
        }
    }
}

SelectionSort 时间复杂度O(N^2)

void selectionSort(SqList L)
{
    int i,j;
    int min;

    for(i=1;i<L->length;i++)
    {
        min = i;
        for(j=i+1;j<=L->length;j++)
        {
            if(L->r[min] > L->r[j])
            {
                min = j;
            }
            if(min != i)
            {
                swap(L,i,min);
            }
        }
    }
}

InsertSort 空间上只需要一个记录的辅助空间，时间复杂度O(N^2)

void InsertSort(SqList *L)
{
    int i,j;

    for(int i=2;i<=length;i++)
    {
        if(L->r[i] < L->r[i-1])
        {
            L->r[0] = L->r[i];
            for(j=i-1;L->r[j]>L->r[0];j--)
                L->r[j+1] = L->r[j];
            L->r[j+1] = L->r[0];
        }
    }
}

接下来的的排序算法将算法的时间复杂度缩短为O(nlogn)
ShellSort 本质上来说也是一种 InsertSort

void shellSort(SqList *L)
{
    int i,j;
    int increment = L->length;

    do{
        for(i=increment+1;i<=L->length;i++)
        {
            L(L->r[i] < L->r[i-increment])
            {
                L->r[0] = L->r[i];
                for(j=i-increment+1;j>0&&L->r[0]<L->r[j];j -= increment)
                    L->r[j+increment] = L->r[0];
            }
        }
    }
    while(increment>1);
}

发现这个排序代码实现的理解有点困难！
下一个排序 MergeSort
有没有 更直接更简单的利用完全二叉树来排序的？
Yes is MergeSort

MergeSort 的递归实现

void MergeSort(SqList *L)
{
    MSort(L->r,L->r,1,L->length);
}

void MSort(int SR[],int TR1[],int s,int t)
{
    int m;
    int TR2[MAXSIZE+1];

    if(s==t){
        TR1[s] == SR[s];
    }
    else
    {
        m = (s+t)/2;
        MSort(SR,TR2,s,m);//递归将SR[s..m]归并为有序的TR2[s...m]
        MSort(SR,TR2,m+1,t);//递归将SR[m+1..t]归并为有序的TR2[m+1..t]
        Merge(TR1,TR2,s,m,t);
    }
}