经典排序算法+文件操作~c语言实现

 #include <malloc.h>
 #include <stdio.h>
 #include <time.h>
 #include <stdlib.h>
 #define MAXSIZE 10
typedef struct {
     int L[MAXSIZE+1];
     int length;
 
 }List,*list;
 void swap(List &L,int low,int high){
     int temp;
     temp=L.L[low];
     L.L[low] = L.L[high];
     L.L[high]=temp;
 }
 /**************************************
  *                 快速排序           *
  * ************************************/
 
 int Partition(List &L,int low,int high){
     int pro;
     pro=L.L[low];
     while(low<high){
 
         while(L.L[high]>=pro&&low<high){
                 high--;
         }
         swap(L,low,high);
         while(L.L[low]<=pro&&low<high){
             low++;
         }
 
 
         swap(L,low,high);
 
     }
     //L.L[low]=L.L[0];
     return low;
 
 }
 void Qsort(List &list,int low,int high){
     int pivot;
     if(low<high){
         pivot = Partition(list,low,high);
         Qsort(list,low,pivot-1);
         Qsort(list,pivot+1,high);
     }
 
 }
 
 
 /****************************
  *             冒泡排序            *
  * **************************/
  void bubbleSort(List &list){
      int i,j;
      bool flag=1;
      for(i=1;i<=list.length&&flag;i++){
          flag=0;
          for(j=list.length-1;j>=i;j--){
              if(list.L[j]>list.L[j+1]){
                  swap(list,j,j+1);
                  flag=1;
              }
          }
      }
 
  }
 /***************************
  *        简单选择排序      *
  ***************************/
  void selectSort(List &list){
      int i,j,min;
      for(i=0;i<=list.length;++i){
          min=i;
          for(j=i+1;j<=list.length;++j){
              if(list.L[min]>list.L[j]){
                  //swap(list,min,j);
                  min=j;
              }
          }
         if(i!=min){
              swap(list,min,i);
          }
      }
 
  }
  /*************************
   *     直接插入排序          *
   *************************/
  void insertSort(List &list){
      int i,j;
      for(i=2;i<=list.length;++i){
          if(list.L[i]<list.L[i-1]){
              list.L[0]=list.L[i];
              for(j=i-1;list.L[j]>list.L[0];--j){
                  list.L[j+1]=list.L[j];
              }
             list.L[j+1]=list.L[0];
          }
      }
  }
 /***********************
  *         希尔排序    *
  ***********************/
  void sheelSort(List &list){
      int i,j;
      int increment=list.length;
 
      do{
          increment = increment/3+1;
          for(i=increment+1;i<=list.length;++i){
              if(list.L[i]<list.L[i-increment]){
                 list.L[0]=list.L[i];
                  for(j=i-increment;list.L[0]<list.L[j]&&j>0;j-=increment){
                      list.L[j+increment]=list.L[j];
                  }
                  list.L[j+increment] = list.L[0];
              }
          }
      }while(increment!=1);
 
  }
   /***********************
 2   *      归并排序       *
 3   ***********************/
 
 void merge(int SR[],int TR[],int i,int m,int n){
       int j,k,l;
       for(j=m+1,k=i;i<=m&&j<=n;k++){
           if(SR[i]<SR[j]){
               TR[k]=SR[i++];
           }else{
               TR[k]=SR[j++];
           }
       }
         if(i<=m){
               for(l=0;l<=m-i;l++){
                  TR[k+l]=SR[i+l];
               }
           }
           if(j<=n){
               for(l=0;l<=n-j;l++){
                   TR[k+l]=SR[j+l];
               }
           }
 
 
   }
 
  void mergePass(int SR[],int TR[],int s,int n){
      int i=1;
      int j;
      while(i<=n-(2*s)+1){
          merge(SR,TR,i,i+s-1,i+(2*s)-1);
          i=i+(2*s);
 
      }
      if(i<n-s+1){
          merge(SR,TR,i,i+s-1,n);
      }else{
          for(j=i;j<=n;j++){
              TR[j]=SR[j];
          }
      }
 
 
  }
 void mergeSort2(List* list){
      int *TR = (int*)malloc((list->length+1)*sizeof(int));
      int k=1;
     while(k<list->length){
          mergePass(list->L,TR,k,list->length);
          k=2*k;
          mergePass(TR,list->L,k,list->length);
          k=2*k;
      }
 
  }
  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);
          mSort(SR,TR2,m+1,t);
          merge(TR2,TR1,s,m,t);
      }
  }
  void mergeSort(List* list){
     mSort(list->L,list->L,1,list->length);
  }
 
/****************** 
 *      文件操作    * 
 ******************/
int createSourceFile(){
    FILE *fp;
      if((fp = fopen("source.txt","w+"))==NULL){
          printf("can not open");
           return 1;
           //exit(0);
      }
       srand(time(NULL));
       int tag;
   for(tag=1;tag<=MAXSIZE;tag++){
         
     //    list.L[tag] = rand()%2000;
         fprintf(fp,"%d ",rand()%2000);
     }
     fclose(fp);
     return 0;
}  
void readSourceFile(List & list){
    FILE *fp;
      if((fp = fopen("source.txt","r"))==NULL){
          printf("can not open");
           exit(0);
      }
      int tag;
   for(tag=1;tag<=MAXSIZE;tag++){
         
     //    list.L[tag] = rand()%2000;
         fscanf(fp,"%d ",&list.L[tag]);
         //printf("%d ",list.L[tag]);
     }
     fclose(fp);
}
void createToFile(List &list){
    FILE *fp;
      if((fp = fopen("to.txt","w+"))==NULL){
          printf("can not open");
           exit(0);
      }
       srand(time(NULL));
       int tag;
   for(tag=1;tag<=MAXSIZE;tag++){
         
     //    list.L[tag] = rand()%2000;
         fprintf(fp,"%d ",list.L[tag]);
         if(tag%5==0){
         fprintf(fp,"\n");
         }
     }
     fclose(fp);
}
/********************
 *        查看list    *
 ********************/
void show(List &list){
    int i;
    for(i=1;i<MAXSIZE+1;i++){
    printf("%d,",list.L[i]);
    }
    printf("\n");
}

/******************
 *        菜单     * 
 *****************/
 
void mune(){
    printf("         ********************\n\
     *     排序大集合   *\n\
     ********************\n\
    ----------------------\n\
    |  1.生成随机数文件\n\
    |  2.快速排序\n\
    |  3.冒泡排序\n\
    |  4.简单选择排序\n\
    |  5.直接插入排序\n\
    |  6.希尔排序\n\
    |  7.归并排序（递归）\n\
    |  8.归并排序（非递归）\n\
    |  9.保存至文件\n\
    |  #.查看数据\n\
    |  0.退出\n\
    ----------------------\n\
    请输入您的指令\n");

     //return 
 }

 int main(){

     List list={{0},MAXSIZE};
     //Qsort(list,0,9);    //快速排序
     //bubbleSort(list);
     //selectSort(list);
     //insertSort(list);
    
     //createSourceFile();
     //readSourceFile(list);
     mune();
     char num='1';
    for(num;num!='0';){
        
         scanf("%c",&num); 
         getchar();
          switch(num){
        case '1':
        if(createSourceFile()){
            printf("file error\n");
        }else{
            printf("file create success~~\n");
            readSourceFile(list);
        }
            break;
        case '2':
            readSourceFile(list);
            Qsort(list,0,MAXSIZE);
            printf("操作成功~~\n"); 
            break;
        case '3':
            readSourceFile(list);
            bubbleSort(list);
            printf("操作成功~~\n");
            break;
        case '4':
            readSourceFile(list);
            selectSort(list);
            printf("操作成功~~\n");
            break;
        case '5':
            readSourceFile(list);
            insertSort(list);
            printf("操作成功~~\n");
            break;
        case '6':
            readSourceFile(list);
            sheelSort(list);
            printf("操作成功~~\n");
            break;
        case '7':
            readSourceFile(list);
            mergeSort(&list);
            printf("操作成功~~\n");
            break;
        case '8':
            readSourceFile(list);
            mergeSort2(&list);
            printf("操作成功~~\n");
            break;
        case '9':
            createToFile(list);
            printf("操作成功~~\n");
            break;
        case '#':
            
            show(list);
            break;
        default :
            printf("输入有误，请重输\n");
    }
        
    }

     return 0;
 }
 

友情链接：http://happyrxk.cn