排序算法

   排序算法

                    插入排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;//关键字项

    char data;//其他数据项

}RecordType;//记录类型

void D_Insert(RecordType R[],int n)

{//对n个记录进行直接插入排序

    int i,j;

    for(i=2;i<=n;i++)//进行n-1趟排序

        if(R[i].key<R[i-1].key)

         {

             R[0]=R[i];//设置查找监视哨

             j=i-1;

            while(R[j].key>R[0].key)

             {

                R[j+1]=R[j];

                 j--;

             }

            R[j+1]=R[0];//相应位置

         }

}

void main()

{

    int i=1,j,x;

    RecordTypeR[MAXSIZE];//记录类型数组

    printf("Inputdata of list(-1 stop):\n");//给每个记录输入关键字

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)//输出表中各记录的关键字

   printf("%4d",R[j].key);

   printf("\nSort:\n");

    D_Insert(R,i-1);

    printf("\nOutputdata inlist after Sort；\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\n");

}

                          堆排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void HeapAdjust(RecordType R[],int s,int t)//基于大根堆的堆排序

{

    int i,j;

    R[0]=R[s];//R[s]暂存R[0]

    i=s;

   for(j=2*i;j<=t;j=2*j)//沿关键字较大的孩子向下调整，先假定为左孩子

    {

       if(j<t&&R[j].key<R[j+1].key)

        j=j+1;//右孩子结点的关键字大则右孩子向下调整

       if(R[0].key>R[j].key)

        break;

        R[i]=R[j];//将关键字大的孩子节点调整至双亲结点

        i=j;//定位于孩子节点继续向下调整

    }

    R[i]=R[0];

}

void HeapSort(RecordType R[],int n)//进行堆排序

{

    int i;

    for(i=n/2;i>0;i--)

    HeapAdjust(R,i,n);

    for(i=n;i>1;i--)

    {

        R[0]=R[1];

        R[1]=R[i];

        R[i]=R[0];

       HeapAdjust(R,1,i-1);

    }

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list(-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\nSort:\n");

    HeapSort(R,i-1);

    printf("Outputdata in list after Sort:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

    printf("\n");

}

                                归并排序的递归算法实现

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void Merge(RecordType R[],RecordType R1[],int s,int m,int t)//一趟二路归并

{

    int i,j,k;

    i=s;

    j=m+1;

    k=s;

   while(i<m&&j<=t)//将两个有序的记录按关键字大小收集到表R1中使表R1也为有序表

   if(R[i].key<=R[j].key)

    R1[k++]=R[i++];

    else

       R1[k++]=R[j++];

       while(i<=m)//将第一个有序表未收集完的记录收集到有序表R1

       R1[k++]=R[i++];

       while(j<=t)//将第二个有序表未收集完的记录收集到有序表R1

       R1[k++]=R[j++];

}

void MSort(RecordType R[],RecordType R1[],int s,int t)//递归方式的归并排序

{

    int m;

    RecordTypeR2[MAXSIZE];

    if(s==t)

    R1[s]=R[s];

    else

     {

         m=(s+t)/2;//找到无序表的中间位置

         MSort(R,R2,s,m);//递归方式将前半个表归并为有序表

        MSort(R,R2,m+1,t);//将后半个归并为有序表

        Merge(R2,R1,s,m,t);

     }

}

void main()

{

    int i=1,j,x;

    RecordTypeR[MAXSIZE],R1[MAXSIZE];

    printf("Inputdata of list(-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\nSort:\n");

    MSort(R,R1,1,i-1);

    printf("\nOutputdata in list after Sort :\n");

    for(j=1;j<i;j++)

   printf("%4d",R1[j].key);

   printf("\n");

}

                       归并排序的非递归算法实现

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void Merget(RecordType R[],RecordType R1[],int k,int n)//R1为归并中使用的暂存数组

{

    inti,j,u1,u2,l1,l2,m;//l1、l2、u1、u2分别为进行归并的两个有序子表的上下界

    l1=0;//初始时第一个有序子表的下界值为0

    m=0;//m为数组的存放指针

    while(l1+k<n)//归并中的两个字表其第一个子表长度为k

    {

        l2=l1+k;//l2指向第二个子表的开始处

        u1=l2-1;//u1指向第一个子表的末端

        if(l2+k-1<n)

        u2=l2+k-1;//u2指向归并中的第二个子表的末端

        else

          u2=n-1;//归并中第二个子表归并为一个有序子表且暂存于R1

         for(i=l1,j=l2;i<=u1&&j<=u2;m++)//俩个有序子表归为一个有序子表

         if(R[i].key<=R[j].key)

          R1[m]=R[i++];

          else

            R1[m]=R[j++];

           while(i<=u1)//第二个子表已经归并完，将第一个子表剩余的记录复制给R1

           R1[m++]=R[i++];

           while(j<=u2)//第一个子表已经归并完，将第二个子表剩余的记录复制到R1

           R1[m++]=R[j++];

            l1=u2+1;//将l1调整到下两个未归并子表开始处继续归并

    }

    for(i=l1;i<n;i++,m++)//归并到仅剩一个子表且长度又小于看时

    R1[i]=R[i];//直接复制子表中的记录到R1

}

void MergeSort(RecordType R[],int n)//非递归的归并

{

    int i,k;

    RecordTypeR1[MAXSIZE];

    k=1;//初始化待归并的有序子表

    while(k<n)//未归并时

    {

       Merget(R,R1,k,n);//进行一趟二路归并

        for(i=0;i<n;i++)

        R[i]=R1[i];

        k=2*k;//长度变为原来的二倍

    }

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list (-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\nSort:\n");

    MergeSort(R,i-1);

    printf("\nOutputdata in list after Sort:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

    printf("\n");

}

                              基数排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

#define Radix_MAX 10

#define d_MAX 3

typedef struct

{

    int key;

    int keys[d_MAX];//存放拆分后的关键字

    int next;//指向下一记录的指针

    char data;

}RecType;//基数排序的记录类型

void RadixSort(RecType R[],int d,int c1,int ct)

{//进行基数排序

    inti,j,k,m,p,t,f[Radix_MAX],e[Radix_MAX];

    p=1;

    for(i=0;i<d;i++)//进行d趟分配与收集

    {

       for(j=c1;j<=ct;j++)//分配前清空队头指针

        f[j]=0;

        while(p!=0)//未分配到最后一个记录R[n]

        {

           k=R[p].keys[i];//k为R[p]中第i个关键字项

            if(f[k]==0)//第k个队列是否为空

            f[k]=p;//作为第k个队列的对头结点插入

            else

            R[e[k]].next=p;//连接到第k个队列的队尾结点

             e[k]=p;//第k个队列的队尾指针指向新的队尾结点

            p=R[p].next;//取出排在R[p]之后的记录继续分配

        }

        j=c1;//收集c1~ct个队列记录

        while(f[j]==0)//j队列为空时继续查找下一个非空队列

        j++;

        p=f[j];t=e[j];//找到第一个非空队列p指向队头，t指向队尾

        while(j<ct)//未收集完最后一个队列时则继续收集

        {

            j++;//使j指向最后一个队列

            if(f[j]!=0)//后一个队列不为空

            {

               R[t].next=f[j];//将后一个队列的队头链到前一个队列的队尾

                t=e[j];//使t指向这后一个队列的队尾继续进行对下一个队列的收集

            }

            R[t].next=0;//收集完毕记录标志

        }

        m=p;//m指向链队列的队头

       printf("%5d",R[m].key);//先输出队头记录的关键字

        do//继续输出其余记录的关键字

        {

            m=R[m].next;

           printf("%5d",R[m].key);

       }while(R[m].next!=0);

       printf("\n");

    }

}

void DistKeys(RecType R[],int n,int d,int c1,int ct)

{//将但关键字分离为多关键字的基数排序

    int i,j,k;

    for(i=1;i<=n;i++)

    {

        R[i].next=i+1;//将记录链成一个队列

        k=R[i].key;//取出单关键字

       for(j=0;j<d;j++)

        {

           R[i].keys[j]=k%(ct+1);//分离成多关键字

            k=k/(ct+1);

        }

    }

    R[n].next=0;//置最后一个记录为队尾标志

   RadixSort(R,d,c1,ct);//进行基数排序

}

void main()

{

    int i=1,j,x;

    RecType R[MAXSIZE];

    printf("Inputdata of list (-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

    printf("\nSortOutput data in list after Sort:\n");

   DistKeys(R,i-1,d_MAX,0,9);

}

                                    快速排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

int Partition(RecordType R[],int i,int j)//划分算法

{

    R[0]=R[i];//暂存基准记录

    while(i<j)//从表的两端交替向中间扫描

    {

       while(i<j&&R[j].key>=R[0].key)//从右向左扫描查找第一个关键字小于R[0].key的记录

        j--;

        if(i<j)//当i<j时则R[j].key小于R[0].key将R[j]交换到表的左端

        {

            R[i]=R[j];

            i++;

        }

       while(i<j&&R[i].key<=R[0].key)//从左向右进行扫描

        i++;

        if(i<j)

        {

            R[j]=R[i];

            j--;

        }

    }

    R[i]=R[0];

    return i;

}

void QuickSort(RecordType R[],int s,int t)//进行快速排序

{

    int i;

    if(s<t)

    {

       i=Partition(R,s,t);

       QuickSort(R,s,i-1);

       QuickSort(R,i+1,t);

    }

}

void main()

{

int i=1,j,x;

RecordType R[MAXSIZE];

printf("Input data of list(-1 stop):\n");

scanf("%d",&x);

while(x!=-1)

{

    R[i].key=x;

   scanf("%d",&x);

    i++;

}

printf("Output data in list:\n");

for(j=1;j<i;j++)

printf("%4d",R[j].key);

QuickSort(R,1,i-1);

printf("\nOutput data in list after Sort:\n");

for(j=1;j<i;j++)

printf("%4d",R[j].key);

printf("\n");

}

                            冒泡排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void BubbleSort(RecordType R[],int n)

{

    int i,j,swap;

    for(i=1;i<n;i++)

    {

        swap=0;

       for(j=1;j<=n-1;j++)

          if(R[j].key>R[j+1].key)

           {

               R[0]=R[j];

               R[j]=R[j+1];

              R[j+i]=R[0];

               swap=1;

           }

           if(swap==0)

           break;

    }

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list(-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list :\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

    BubbleSort(R,i-1);

    printf("\nOutputdata in list after Sort:\n");

    for(j=1;j<i;j++)

    printf("%4d",R[j].key);

   printf("\n");

}

                          双向冒泡排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void DBubbleSort(RecordType R[],int n)

{

    int i,j,swap=1;

    for(i=1;swap!=0;i++)

    {

        swap=0;

       for(j=n-1;j>=i;j--)//从右到左进行冒泡

   if(R[j+1].key<R[j].key)

    {

        R[0]=R[j];

        R[j]=R[j+1];

        R[j+1]=R[0];

    }

   for(j=i+1;j<=n-i;j++)//从左到右进行冒泡

   if(R[j+1].key<R[j].key)

    {

        R[0]=R[j];

        R[j]=R[j+1];

        R[j+1]=R[0];

        swap=1;//有交换发生

    }

}

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list (-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

    DBubbleSort(R,i-1);

    printf("\nOutputdata in list after Sort:\n");

    for(j=1;j<i;j++)

    printf("%4d",R[j].key);

   printf("\n");

}

                               希尔排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void ShellInsert(RecordType R[],int n,int d)//希尔排序

{

    int i,j;

    for(i=d+1;i<=n;i++)

       if(R[i].key<R[i-1].key)

        {//当R[i].key小于前一步长d的R[i-d].key应向前找寻其插入位置

            R[0]=R[i];//暂存待插入记录的值

           for(j=i-d;j>0&&R[0].key<R[j].key;j=j-d)

            R[j+d]=R[j];

            R[j+d]=R[0];//将原R[j]也即此时的R[0]插入到应该插入的位置

        }

}

void ShellSort(RecordType R[],int n)//按递增做希尔排序

{

    int d[10],t,k;

    printf("\n输入增量因子的个数:\n");

   scanf("%d",&t);

    printf("由大到小输入每一个增量因子:\n");

    for(k=0;k<t;k++)

   scanf("%d",&d[k]);

    for(k=0;k<t;k++)

    ShellInsert(R,n,d[k]);

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list (-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

    R[i].key=x;

   scanf("%d",&x);

    i++;

}

printf("Output data in list:\n");

for(j=1;j<i;j++)

printf("%4d",R[j].key);

ShellSort(R,i-1);

printf("\nOutput data in list after Sort:\n");

for(j=1;j<i;j++)

printf("%4d",R[j].key);

printf("\n");

}

                   选择排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void SelectSort(RecordType R[],int n)//对R[1]~R[n]这n个记录进行选择性排序

{

    int i,k,j;

    for(i=1;i<n;i++)//进行n-1趟选择

    {

        k=i;//假设关键字最小的记录为i个记录

       for(j=i+1;j<=n;j++)

        if(R[j].key<R[k].key)

        k=j;//保存最小关键字的存放记录

        if(i!=k)//将找到的最小关键字的记录与第i个记录交换

        {

            R[0]=R[k];

            R[k]=R[i];

            R[i]=R[0];

        }

    }

}

void main()

{

    int i=1,j,x;

    RecordTypeR[MAXSIZE];//定义记录类型数组

    printf("Inputdata of list(-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

    printf("%4d",R[j].key);

   printf("\nSort:\n");

    SelectSort(R,i-1);

    printf("\nOutputdata in list after Sort:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\n");

}

                             折半插入排序

#include <stdio.h>

#include <stdlib.h>

#define MAXSIZE 30

typedef struct

{

    int key;

    char data;

}RecordType;

void B_InsertSort(RecordType R[],int n)

{//对n个记录序列进行折半插入排序

    int i,j,low,high,mid;

    for(i=2;i<=n;i++)//进行n-1趟排序

    {

        R[0]=R[i];//设置查找监视哨

        low=1,high=i-1;//设置初始查找区间

       while(low<=high)//寻找插入位置

        {

           mid=(low+high)/2;

           if(R[0].key>R[mid].key)

            low=mid+1;//插入在右半区

            else

             high=mid-1;//左半区

        }

       for(j=i-1;j>=high+1;j--)

        R[j+1]=R[j];

        R[high+1]=R[0];

    }

}

void main()

{

    int i=1,j,x;

    RecordType R[MAXSIZE];

    printf("Inputdata of list (-1 stop):\n");

   scanf("%d",&x);

    while(x!=-1)

    {

        R[i].key=x;

       scanf("%d",&x);

        i++;

    }

    printf("Outputdata in list:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\nSort:\n");

    B_InsertSort(R,i-1);

    printf("\nOutputdata in list sfter Sort:\n");

    for(j=1;j<i;j++)

   printf("%4d",R[j].key);

   printf("\n");

}