数据结构C语言-9种排序算法（插入、交换、选择、归并、基数排序）

以下代码包含：
直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序

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

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int status;
typedef int ElemType;

#define MAXSIZE 20
typedef int KeyType;
typedef int InfoType;
typedef struct
{
    KeyType key;
    InfoType otherinfo;
}RedType;
typedef struct
{
    RedType r[MAXSIZE+1];
    int length;
}SqList;

//直接插入排序
void InsertSort(SqList *L)
{
    int i,j;
    for(i=2;i<=L->length;i++)
        if(L->r[i].key<L->r[i-1].key)
        {
            L->r[0]=L->r[i];
            L->r[i]=L->r[i-1];
            for(j=i-2;L->r[0].key<L->r[j].key;j--)
                L->r[j+1]=L->r[j];
            L->r[j+1]=L->r[0];
        }
}

//折半插入排序
void BInsertSort(SqList *L)
{
    int i,j;
    for(i=2;i<=L->length;i++)
    {
        L->r[0]=L->r[i];
        int low=1,high=i-1,m;
        while(low<=high)
        {
            m=(low+high)/2;
            if(L->r[0].key<L->r[m].key)
                high=m-1;
            else
                low=m+1;
        }
        for(j=i-1;j>=high+1;--j)
            L->r[j+1]=L->r[j];
        L->r[high+1]=L->r[0];
    }
}

//希尔排序,dk为初始增量
void ShellInsert(SqList *L,int dk)
{
    int i,j;
    for(i=dk+1;i<=L->length;i++)
        if(L->r[i].key<L->r[i-dk].key)
        {
            L->r[0]=L->r[i];
            for(j=i-dk;j>0&&L->r[0].key<L->r[j].key;j-=dk)
                L->r[j+dk]=L->r[j];
            L->r[j+dk]=L->r[0];
        }
}

void ShellSort(SqList *L,int dt[],int t)
{
    int k;
    for(k=0;k<t;k++)
        ShellInsert(L,dt[k]);
}

//冒泡排序
void BubbleSort(SqList *L)
{
    int m=L->length-1,flag=1,j;//flag=1表示进行了交换
    while(m>0&&flag)
    {
        flag=0;
        for(j=1;j<=m;j++)
            if(L->r[j].key>L->r[j+1].key)
            {
                flag=1;
                RedType t=L->r[j];
                L->r[j]=L->r[j+1];
                L->r[j+1]=t;
            }
        m--;
    }
}

//快速排序
int Partition(SqList *L,int low,int high)
{
    L->r[0]=L->r[low];
    KeyType p=L->r[low].key;
    while(low<high)
    {
        while(low<high&&L->r[high].key>=p)
            high--;
        L->r[low]=L->r[high];
        while(low<high&&L->r[low].key<=p)
            low++;
        L->r[high]=L->r[low];
    }
    L->r[low]=L->r[0];
    return low;
}
void QSort(SqList *L,int low,int high)
{
    if(low<high)
    {
        int p=Partition(L,low,high);
        QSort(L,low,p-1);
        QSort(L,p+1,high);
    }
}

//简单选择排序
void SelectSort(SqList *L)
{
    int i,k,j;
    for(i=1;i<L->length;i++)
    {
        k=i;
        for(j=i+1;j<=L->length;j++)
            if(L->r[j].key<L->r[k].key)
               k=j;
        if(k!=i)
        {
            RedType t=L->r[i];
            L->r[i]=L->r[k];
            L->r[k]=t;
        }
    }
}

//堆排序
void HeapAdjust(SqList *L,int s,int m)
{
    RedType rc=L->r[s];
    int j;
    for(j=2*s;j<=m;j*=2)
    {
        if(j<m&&L->r[j].key<L->r[j+1].key)
            j++;
        if(rc.key>=L->r[j].key)
            break;
        L->r[s]=L->r[j];
        s=j;
    }
    L->r[s]=rc;
}
void CreateHeap(SqList *L)
{
    int n=L->length,i;
    for(i=n/2;i>0;i--)
        HeapAdjust(L,i,n);
}
void HeapSort(SqList *L)
{
    CreateHeap(L);
    int i;
    for(i=L->length;i>1;i--)
    {
        RedType x=L->r[1];
        L->r[1]=L->r[i];
        L->r[i]=x;
        HeapAdjust(L,1,i-1);
    }
}

//归并排序
void Merge(RedType *R,int low,int mid,int high)
{
    RedType T[high+1];//不是high-low+1,会没有对应位置
    int i=low,j=mid+1,k=low;
    while(i<=mid&&j<=high)
    {
        if(R[i].key<=R[j].key)
            T[k++]=R[i++];
        else
            T[k++]=R[j++];
    }
    while(i<=mid)
        T[k++]=R[i++];
    while(j<=high)
        T[k++]=R[j++];
    for(i=low;i<=high;i++)
        R[i]=T[i];
}
void MSort(RedType *R,int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MSort(R,low,mid);
        MSort(R,mid+1,high);
        Merge(R,low,mid,high);
    }
}
void MergeSort(SqList *L)
{
    MSort(L->r,1,L->length);
}

//基数排序
#define MAXNUM_KEY 8
#define RADIX 10
#define MAX_SPACE 10000
typedef struct
{
    KeyType keys[MAXNUM_KEY];
    InfoType otheritems;
    int next;
}SLCell;
typedef struct
{
    SLCell r[MAX_SPACE];
    int keynum;
    int recnum;
}SLList;
typedef int ArrType[RADIX];
void Distribute(SLCell *r,int i,ArrType *f,ArrType *e)
{
    int j,p;
    for(j=0;j<RADIX;j++)
        (*f)[j]=0;//需要加括号和星(*)
    for(p=r[0].next;p;p=r[p].next)
    {
        j=r[p].keys[i];
        if(!(*f)[j])
        {
            (*f)[j]=p;
        }
        else
        {
            r[(*e)[j]].next=p;
        }
        (*e)[j]=p;
    }
}
void Collect(SLCell *r,int i,ArrType f,ArrType e)
{
    int j;
    for(j=0;!f[j];j++);
    r[0].next=f[j];
    int t=e[j];
    while(j<RADIX-1)
    {
        for(j=j+1;j<RADIX-1&&!f[j];j++);
        if(f[j])
        {
            r[t].next=f[j];
            t=e[j];
        }
    }
    r[t].next=0;
}
void RadixSort(SLList *L)
{
    int i;
    ArrType f,e;
    for(i=0;i<L->recnum;++i)
        L->r[i].next=i+1;
    L->r[L->recnum].next=0;
    for(i=L->keynum-1;i>=0;i--)
    {
        Distribute(L->r,i,&f,&e);//数组地址
        Collect(L->r,i,f,e);
    }
}

//列表输出
void PrintList(SqList L)
{
    int i=1;
    for(;i<=L.length;i++)
        printf("%d ",L.r[i].key);
    printf("\n");
}

int main()
{
    SqList L;
    KeyType k[10]={49,38,65,97,76,13,27,49,55,04};
    L.length=10;
    int i,j;
    for(i=1;i<=L.length;i++)
        L.r[i].key=k[i-1];
    printf("orinal list:\n");
    PrintList(L);

    //printf("直接插入排序...\n");
    //InsertSort(&L);
    //printf("折半插入排序...\n");
    //BInsertSort(&L);
    //printf("希尔排序...\n");
    int dt[3]={5,3,1},t=3;
    //ShellSort(&L,dt,t);
    //printf("冒泡排序...\n");
    //BubbleSort(&L);
    //printf("快速排序...\n");
    //QSort(&L,1,L.length);
    //printf("简单选择排序...\n");
    //SelectSort(&L);
    //printf("堆排序...\n");
    //HeapSort(&L);
    printf("归并排序...\n");
    MergeSort(&L);
    /*
    printf("基数排序...\n");
    SLList SL;
    SL.keynum=3;
    SL.recnum=10;
    char keyString[][3]={"278","109","063","930","589","184","505","269","008","083"};//第二维必须初始化
    for(i=1;i<=SL.recnum;i++)
        for(j=0;j<SL.keynum;j++)
            SL.r[i].keys[j]=keyString[i-1][j]-'0';
    printf("orinal list:\n");
    for(i=1;i<=SL.recnum;i++)
    {
        for(j=0;j<SL.keynum;j++)
            printf("%d",SL.r[i].keys[j]);
        printf(" ");
    }
    printf("\n");
    RadixSort(&SL);
    printf("sorted list:\n");
    for(i=SL.r[0].next;i;i=SL.r[i].next)//用next输出
    {
        for(j=0;j<SL.keynum;j++)
            printf("%d",SL.r[i].keys[j]);
        printf(" ");
    }
    printf("\n");
    */
    printf("sorted list:\n");
    PrintList(L);
    return 0;
}