C语言实现 排序源程序(包括直接插入、希尔、冒泡、快速、简单选择、堆排序)

在WINDOWS2000/XP,TC2.0下调试通过

#include "stdlib.h"
#include <stdio.h>
#define s 100
typedef struct record
{int key;};
static  struct record a1[s],a2[s],a3[s],a4[s],a5[s],a6[s],rec;
int a[7],b[7];
file()
 {
 printf("                *********************************  /n");
 printf("                ***      *1. 直接插入排序     ***  /n");
 printf("                ***      *2. 希尔排序         ***  /n");
 printf("                ***      *3. 冒泡排序         ***  /n");
 printf("                ***      *4. 快速排序         ***  /n");
 printf("                ***      *5. 简单选择排序     ***  /n");
 printf("                ***      *6. 堆排序           ***  /n");
 printf("                ***      *7. 总结             ***  /n");
 printf("   ***   *0. 退出             ***  /n");
 printf("                *********************************  /n");   }

 void Straight_insert_sort(r,n) /*直接插入*/
struct record r[];
int n;
 { int i,j;
    a[1]=0;b[1]=0;
     for(i=1;i<=n;i++)
      printf("%4d",r[i].key);
      printf("/n");
  for(i=2;i<=n;i++)
   {  r[0]=r[i];
      j=i-1;
      while((j>=0) && (r[0].key<r[j].key))
       { b[1]++;
  r[j+1]=r[j--];
  r[j+1]=r[0];
  a[1]=a[1]+2;
 }
     }
   printf("************直接插入******************/n");
   for(i=1;i<=n;i++)
   printf("%4d",r[i]);
   printf("/n");
   printf("move:%d  time,    compete:%d  time",a[1],b[1]);
   printf("/n");
 }

void Shell_sort(r,n)   /*     希 尔 排 序    */
struct record r[];
int n;
{   struct record rec,temp;
    int i,j,t,h;
    a[2]=0;b[2]=0;
    for(i=1;i<=n;i++)
    printf("%4d",r[i].key);
    printf("/n");
    t=n/2;
   while(t>=1)
    { h=t;
      for(j=h;j<n;j++)
       {  rec=r[j];
  i=j-h;
  while((i>=0) && (r[i].key>rec.key))
   { b[3]++;
     temp=r[i+h];
     r[i+h]=r[i];
     r[i]=temp;
     i=i-h;
     a[2]=a[2]+3;
   }
 }
  t=t/2;
  b[2]++;

    }
   printf("************************希 尔 排 序**************************/n");
   for(i=0;i<n;i++)
   printf("%4d",r[i]);
   printf("/n");
   printf("move:%d  time,     compete:%d  time",a[3],b[3]);
   printf("/n");
 }

 void Bubblle_sort(r,n)  /*     冒 泡 排 序    */
struct record r[];
int n;
 {   struct record rec;
     int i,j,m,flag;
     a[3]=0;b[3]=0;
     for(i=1;i<=n;i++)
     printf("%4d",r[i].key);
     printf("/n");
     m=n;
     flag=1;
     for(i=1;i<=m-1;i++)
      { flag=0;
  for(j=0;j<=m-i-1;j++)
  if(r[j].key>r[j+1].key)
   { b[3]++;
      rec.key=r[j].key;
      r[j].key=r[j+1].key;
      r[j+1].key=rec.key;
      a[3]=a[3]+3;
      flag=1;
    }
  if(flag==0)  break;
      }
   printf("*************冒 泡 排 序****************/n");
   for(i=0;i<n;i++)
   printf("%4d",r[i].key);
    printf("/n");
      printf("move: %d  time,       compete: %d  time",a[3],b[3]);
     printf("/n");
 }

int push(h,top,m,n)
int  h[];
 int top ,m,n;
  { h[++top]=m;
    h[++top]=n;
    return(top);
   }

int  pop(h,top,m,n)
int h[],  top,*m,*n;
 { *m=h[top--];
   *n=h[top--];
   return(top);
 }

int quick(r,i,j)
struct record r[];
int i,j;
 {
   rec=r[i];
   while(i<j)
    { while((i<j)&&(r[j].key>rec.key))
 j--;
 b[4]++;
      if(i<j)
 r[i++]=r[j];
 a[4]++;
      while((i<j)&&(r[i].key<=rec.key))
 i++;
 b[4]++;
      if(i<j)
 r[j--]=r[i];
 a[4]++;
     }
    r[i]=rec;
    a[4]++;
    return(i);
 }
void Quick_sort(r,l,h)  /*      快 速 排 序    */
struct record r[];
int l,h;
 {  int ss[s];
   int top,i,j,k;
    for(i=1;i<=s;i++)
     printf("%4d",r[i].key);
     printf("/n");
    i=l;
    j=h;
    top=-1;
    do
      { while(i<j)
  {  k=quick(r,i,j);
     if(j-k>1)
       top=push(ss,top,k+1,j);
       j=k-1;
    }
   if(top>0)
     top=pop(ss,top,&j,&i);
       }
     while((top>=0)||(i<j));
   printf("**************************快 速 排 序*************************/n");
   for(i=1;i<=s;i++)
     printf("%4d",r[i].key);
     printf("/n");
   printf("move: %d  time,     compete: %d  time",a[4],b[4]);
 }

void Simple_select_sort(r,n)    /*    简 单 选 择 排 序  */
struct record r[];
int n;
  {
     int i,j,m;
     a[5]=0;b[5]=0;
      for(i=1;i<=n;i++)
       printf("%4d",r[i].key);
       printf("/n");
      for(i=1;i<=n-1;i++)
       {   m=i;
   for(j=i+1;j<=n;j++)
   if(r[j].key<r[m].key)
    m=j;
    b[5]++;
     if(i!=m)
      {  rec=r[i];
   r[i]=r[m];
   r[m]=rec;
   a[5]=a[5]+3;
        }
   }
   printf("************************简 单 选 择************************/n");
    for(i=1;i<=s;i++)
     printf("%4d",r[i].key);
      printf("/n");
       printf("move:%d  time,        compete:%d  time",a[5],b[5]);
       printf("/n");
   }

void p(r,n)    /*     次数排列    */
int  r[];
int n;
 { int rec;
    int i,j;
    for(i=1;i<=n;i++)
      { rec=r[i];
 j=i-1;
  while((j>0) && (rec<r[j]))
    { r[j+1]=r[j];
      j=j-1;
     }
   r[j+1]=rec;}
  if(r==a)
    printf("关 键 字 移 动 次 数 排 列:/n");
  else
    printf("关 键 字 比 较 次 数 排 列:/n");
       for(i=1;i<=n;i++)
       printf("%8d",r[i]);
       printf("/n");
}

void  heap(r,l,m)           /*   堆的子函数   */
struct record r[];
int l,m;
 { int i,j;
   i=l;
   j=2*i;
   rec=r[i];
   while(j<=m)
    { if((j<m)&&(r[j].key>r[j+1].key))
 j++;
 b[6]++;
      if(rec.key>r[j].key)
       {  b[6]++;
   r[i]=r[j];
   i=j;
   j=2*i;
   a[6]++;
 }
       else  j=m+1;
     }
    r[i]=rec;
  }

void Heap_sort(r,n)     /*  堆 排 序 */
struct  record r[];
int  n;
 {
   int  l;
   a[6]=0;b[6]=0;
   for(l=1;l<=n;l++)
    printf("%4d",r[l].key);
    printf("/n");
   for(l=n/2;l>=1;l--)
    heap(r,l,n);
   for(l=n;l>=2;l--)
    { rec=r[1];
      r[1]=r[l];
      r[l]=rec;
      a[6]=a[6]+3;
       heap(r,1,l-1);
     }
   printf("****************************堆 排 序***************************/n");
   for(l=n;l>=1;l--)
    printf("%4d",r[l].key);
    printf("/n");
    printf("move: %d time,         compete: %d time ",a[6],b[6]);
    printf("/n");
  }

 compete()
{
   printf("       ** 内  部  排  序  结  果  汇  总 **                 /n");
   printf("   -------------------------------------------------------- /n");
   printf("                 移动次数       比较次数                     /n");
   printf("   ---------------------------------------------------------/n");
   printf("     直接插入       %6d           %8d            /n ",a[1],b[1]);
   printf("    希尔排序       %6d           %8d            /n ",a[2],b[2]);
   printf("    冒泡排序       %4d           %8d            /n ",a[3],b[3]);
   printf("    快速排序       %4d           %8d            /n ",a[4],b[4]);
   printf("    简单选择       %4d           %8d            /n ",a[5],b[5]);
   printf("    堆的排序       %4d           %8d            /n ",a[6],b[6]);
   printf("   ------------------------------------------------------- /n");
}
main()
{char ch;
int  i,j,t,k;

 printf("***************************/n ");
 printf("请选择初始时数的顺序/n");
 printf("1---完全有序的情况/n");
 printf("2---逆序的情况/n");
 printf("3---随机排序的情况/n");
 printf("0---退出/n");
 printf("***************************/n");
 ch=getch();
 switch(ch)
 {
 case '1': randomize();
 for(i=0;i<s;i++)
 printf("%5d",a[i]=random(100));
 for(i=0;i<s-1;i++)
 for(j=i+1;j<s;j++)
 if(a[i]>a[j])
 {t=a[i];
 a[i]=a[j];
 a[j]=t;
 }
 printf("完全有序的数列为:/n");
 for(i=0;i<s;i++)
 printf("%5d",a[i]);
 printf("/n");
 for(i=1;i<7;i++)
{
   printf("请选择排序算法/n");
  printf(" 冒泡排序-------------------1/n");
 printf("  直接插入排序---------------2/n");
 printf("  简单选择排序---------------3/n");
  printf(" 快速排序-------------------4/n");
 printf("  希尔排序-------------------5/n");
  printf(" 堆排序---------------------6/n");
 printf("  退出-----------------------0/n");
 ch=getch();
 switch(ch)
 {case '0':exit(0);
 case'1': Bubblle_sort(a,s);break;
 case'2': Straight_insert_sort(a,s);break;
 case'3': Simple_select_sort(a,s);break;
 case'4': Quick_sort(a,0,s-1);break;
 case'5': Shell_sort(a,s);break;
 case'6': Heap_sort(a,s);break;
 default:exit(0);
 }
 }break;
  case '2': randomize();
  for(i=0;i<s;i++)
  printf("%5d",a[i]=random(100));
  for(i=0;i<s-1;i++)
  for(j=i+1;j<s;j++)
  if(a[i]<a[j])
  {t=a[i];
  a[i]=a[j];
  a[j]=t;
  }
  printf("逆序的数列为:/n");
  for(i=0;i<s;i++)
  printf("%5d",a[i]);
  printf("/n");
  for(i=0;i<7;i++){
   printf("请选择排序算法/n");
  printf(" 冒泡排序-------------------1/n");
 printf("  直接插入排序---------------2/n");
 printf("  简单选择排序---------------3/n");
  printf(" 快速排序-------------------4/n");
 printf("  希尔排序-------------------5/n");
  printf(" 堆排序---------------------6/n");
 printf("  退出-----------------------0/n");
 ch=getch();
 switch(ch)
 {case '0':exit(0);
 case'1': Bubblle_sort(a,s);break;
 case'2': Straight_insert_sort(a,s);break;
 case'3': Simple_select_sort(a,s);break;
 case'4': Quick_sort(a,0,s-1);break;
 case'5': Shell_sort(a,s);break;
 case'6': Heap_sort(a,s);break;
 default:exit(0);
 }
 }break;
  case '3':printf("从0到%d获得%d个随机数:/n",100-1,s);
randomize();
/*while(k<6)*/
for(i=0;i<s;i++)
printf("%5d",a[i]=random(100));
for(i=0;i<6;i++){
   printf("请选择排序算法/n");
  printf(" 冒泡排序-------------------1/n");
 printf("  直接插入排序---------------2/n");
 printf("  简单选择排序---------------3/n");
  printf(" 快速排序-------------------4/n");
 printf("  希尔排序-------------------5/n");
  printf(" 堆排序---------------------6/n");
 printf("  退出-----------------------0/n");
 ch=getch();
 switch(ch)
 {case '0':exit(0);
 case'1': Bubblle_sort(a,s);break;
 case'2': Straight_insert_sort(a,s);break;
 case'3': Simple_select_sort(a,s);break;
 case'4': Quick_sort(a,0,s-1);break;
 case'5': Shell_sort(a,s);break;
 case'6': Heap_sort(a,s);break;
 default:exit(0);
 }
 }
break;
case '0':exit(0);
default:exit(0);
}
}