2021-01-15

排序算法综合(C++)

---

问题描述

利用随机函数产生N个随机整数（20000以上），对这些数进行多种方法进行排序。
要求：
1)至少采用三种方法实现上述问题求解（提示，可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序）。并把排序后的结果保存在不同的文件中。
2)统计每一种排序方法的性能（以上机运行程序所花费的时间为准进行对比），找出其中两种较快的方法。

---

让我们走进本次排序综合程序。

一、排序综合算法的各个组件

1、头文件以及全局变量

#include<iostream>
#include <cstring>
#include <stdio.h>
#include <fstream>
#include <stdlib.h>
#include <time.h>
using namespace std; 
int N; //随机产生数据的个数 

2、函数声明

void writeData();//随机产生N个数存入txt文件 
int readData(int num[]) ;//读取txt文件中的数据存入数组num[] 
void printData(int num[]); //输出随机产生的N个数据
void menu();//菜单用于选择所需排序算法 

void SInsertSort(int num[]);//直接插入排序算法
void BInsertSort(int num[]);//折半插入排序算法 
void ShellInsertSort(int num[]);//希尔排序算法
void BubbleSort(int num[]);//起泡排序算法 
void QuickSort(int num[],int low,int high);//快速排序算法
void SelectSort(int num[]);//选择排序算法 
void InitHeap(int num[], int i, int j);//大根堆初始化算法
void Heapsort(int num[]);//大根堆排序算法 
void Msort(int num[],int low,int mid,int high); //归并排序中合并算法 
void Mergesort(int num[],int low,int high);//归并排序中拆分算法 

3、写数据（writeData()）

     用于打开txt文件,利用rand()产生随机数并存入txt文档，
     fopen（“x.txt","w"）打开x.txt文档并且写操作
     fclose(fp)关闭fp对象对文档的写入

void writeData(){//随机产生N个数存入txt文件 
 FILE* fp=fopen("data.txt","w");
        for(int i=0;i<N;i++)
       {
          fprintf(fp,"%d ",rand());
      }
    fclose(fp);
} 

4、读数据（readData(int num[])）

     用于读取data.txt文档中的数据并存入num【】数组，首先应该判断文档是否为空，非空时将每个数据存入数组

int readData(int num[]) {//读取txt文件中的数据存入数组num[]
    FILE *fp;
    fp=fopen("data.txt","r");
    if (fp==NULL){
        fclose(fp);
        return 0;
    }
    else
    {
        for (int i=0; i<N;i++){
            fscanf(fp,"%d",&num[i]);
			}
        fclose(fp);
        return 1;
    }
}

5、打印数据（printData(int num[])）

     用于打印排序前后num【】数组的内容

void printData(int num[]) //打印数据 
{
    for(int i=0;i<N;i++)
    {
     cout<<num[i]<<"\t";
    }
    cout<<endl;
}

6.八大排序算法

6.1直接插入排序（ SInsertSort(int num[])）

  记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表

void SInsertSort(int num[]){
for(int i=1;i<N;i++){
	for(int j=i-1;j>=0;j--){
		if(num[j]>num[j+1]){
			swap(num[j],num[j+1]);
		}
	}
  }
} 

6.2 折半插入排序（ BInsertSort(int num[])）

 顺序地把待排序的序列中的各个元素按其关键字的大小，通过折半查找插入到已排序的序列的适当位置。

void BInsertSort(int num[]){
   int mid,low,high,t,i,j;
   for(i=1;i<N;i++){
   	     t=num[i];
         low=0;
         high=i-1;
     	while(low<=high){
   	    	mid=(high+low)/2;
   	    	if(num[mid]>t){
   			    high=mid-1;
		    }
		    else{
			  low=mid+1;
		   }
	   }
	    for (j =i-1;j>=high+1;j--){//将num[high]之后的数据全部后移一位
	    		num[j+1] = num[j];
		}
            num[high+1] = t;//将关键字插入num[high+1]        
   }
   
        	
} 

6.3 希尔排序（ ShellInsertSort(int num[],int dk)）

先将整体待排序列分割成为若干个子序列分别进行直接插入排序，
待整个序列中的记录“基本有序”时，再对整体进行一次直接插入排序，
dk为希尔值 

void ShellInsertSort(int num[],int dk){//dk选择的希尔数 
	 for(int id=dk;id>0;id--){
	 	for(int i=0;i<id;i++){
	 		for(int j=i+id;j<N;j+=id){
	 			if(num[j]<num[j-id]){
	 				int t=num[j];
	 				int n=j-id;
	 				while(n>=0&&num[n]>t){
	 					num[n+id]=num[n];
	 					n=n-id;
					 }
					 num[n+id]=t;
				 }
			 }
		 } 
	 } 
}

6.4 冒泡排序（BubbleSort(int num[])）

  冒大泡：  首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序， 则将两个记录交换一下，
  然后比较第二个和第 三个关键字，以此类推
  冒小泡： 首先将第一个记录的关键字和第二个记录的关键字进行比较，若为顺序， 则将两个记录交换一下，
  然后比较第二个和第三个关键字，以此类推

void BubbleSort(int num[]){
	int tag=0;//标志位 
	cout<<"请选择起泡方式：1、冒大泡，2、冒小泡"<<endl;
	cin>>tag; 
	int i,j;
	switch(tag)	{
		    case 1:
		    	for(i = 0;i<N;i++){
                    for( j =1;j<N-i;j++){
                       if(num[j-1]>num[j]) //冒大泡 
		         	    {
		         	        swap(num[j-1],num[j]);
		                }
                    }
                }
                cout<<"冒大泡排序结果:"<<endl; 
                break;
			case 2:
				for( i = 0;i<N;i++){
                    for( j =1;j<N-i;j++){
                       if(num[j-1]<num[j]) //冒小泡 
		               	{
		             	swap(num[j-1],num[j]);
		             	}
                    }
               }
                cout<<"冒小泡排序结果:"<<endl; 
               break;
           default:
              cout<<"输入错误！请重新输入！"<<endl;
             BubbleSort( num);
    }
} 

6.5 快速排序（QuickSort(int num[],int low,int high)）

   通过一趟排序将待排序列分割为独立的两部分，其中一部分比关键字小，
   一部分比关键字大，然后对两部分继续进行快速排序，以达到整个待排序列有序

void QuickSort(int num[],int low,int high){
	if(low<high){	
	 int i=low;
	 int j=high;
	 int key=num[low];
     while(i<j){
     	while(i<j&&num[j]>key) {
		 j--;
		 }
        if(i<j){
        	num[i++]=num[j];
		}
		 while(i<j&&num[i]<key) {
		 i++;
		 }
		 if(i<j){
     		num[j--]=num[i]; 
	 }
	 }    
	 num[i]=key;
	 QuickSort(num,low,i-1);
	 QuickSort(num,i+1,high);
	 }	 
}

6.6 选择排序（SelectSort(int num[])）

  每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
  顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完

void SelectSort(int num[]){
   int min;
   for(int i=0;i<N;i++){
   	   min=i;
   	   for(int j=i+1;j<N;j++){
   	   	if(num[j]<num[min]){
   	   		min=j;
			  }
		  }
	 swap(num[i],num[min]);
   }
} 

6.7 堆排序（Heapsort(int num[]) ）

  1、初始化堆：根据数组构建大根堆； 
  2、将当前无序区的堆顶元素同该区间的最后一个记录交换，然后将新的无序区调整为新的大根堆

void InitHeap(int num[], int i, int j) {//初始化大根堆						
	int parent=i;										
	int lchild=2*i+1;//i的左孩子									
	while (lchild<j) {
		if (num[lchild]<num[lchild+1]&&lchild<j-1) {	//比较左右子节点 
			lchild++;
		}
		if (num[parent]<num[lchild]) {				
			swap(num[parent],num[lchild]);					
			parent=lchild;								
		}
        lchild=lchild * 2 + 1;								
	}
}
void Heapsort(int num[]) {												
	for (int i=N/2-1;i>= 0;i--) {							
		InitHeap(num,i,N);								
	}								
	for (int i=N-1;i>0;i--)
	{
		swap(num[0],num[i]);//堆顶元素与最后一个元素交换								
		InitHeap(num,0,i);//重新建堆 
}
}

6.8 归并排序（Mergesort(int num[],int low,int high)）

    它分为拆分和合并两大部分，先拆后合。
      拆分：就是将一堆无序的数拆成单个，方便合并。
	  合并：就是将拆分好的数按照排序规则再拼凑起来。

void Msort(int num[],int low,int mid,int high){
	int temp[N];
	int l=low;
	int j=mid+1;
	int m=mid;
	int h=high;
		int i=low;
		  while(l<=m&&j<=h){
        if(num[l]>num[j])
            temp[i++] = num[j++] ;
        else
            temp[i++] = num[l++] ;
    }
    //将两边剩余元素加到temp的末尾 
    while(l<=m) 
        temp[i++] = num[l++] ;
    while(j<=h)
        temp[i++] = num[j++] ;

	for(i=low;i<=high;++i){
	num[i]=temp[i]; 
   }
}
void Mergesort(int num[],int low,int high){
	if(low<high){
	int mid=(low+high)/2;
	Mergesort(num,low,mid);//拆分 
	Mergesort(num,mid+1,high);
	Msort(num,low,mid,high);//合并 
	}
}

}

7、菜单（menu()）

      用于选择你需要的算法，并且将排序结果保存到txt文件中，
       并计算八种排序的上机运行程序所花费的时间，用于比较性能
            double sittime;
	        start=clock(); //开始时间
			 SInsertSort(num);
			 end=clock()；//结束时间
			 sittime=double(end-start);
			 sittime=sittime/CLOCKS_PER_SEC; //毫秒转化为秒

void menu(){
	int num[N];
    int tag=0;
    while(tag!=9){
    	cout<<"$________$Menu$___________$"<<endl; 
	    cout<<" *****1-直接插入排序*****"<<endl;
	    cout<<" *****2-折半插入排序*****"<<endl;
	    cout<<" *****3-希尔排序*********"<<endl;
	    cout<<" *****4-起泡排序*********"<<endl;
	    cout<<" *****5-快速排序*********"<<endl;
	    cout<<" *****6-选择排序*********"<<endl;
	    cout<<" *****7-大根堆排序*******"<<endl;
	    cout<<" *****8-归并排序*********"<<endl;
	    cout<<" *****9-退出*************"<<endl;
	    cout<<"$_________$$$____________$"<<endl;
	    cout<<"   请输入你需要的操作：";
        cin>>tag; 
        double start,end;//开始时间，结束时间 
    	switch(tag){
    	    case 1:{
				readData(num);
    	    	double sittime;
    	    	 start=clock(); 
    			 SInsertSort(num);
    			 end=clock();
    			 sittime=double(end-start);
    			 sittime=sittime/CLOCKS_PER_SEC; 
    			 cout<<"直接插入排序结果："<<endl;
    			 FILE * f1=fopen("data1.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f1,"%d ",num[i]);
                          }
                  printData(num);
                  fclose(f1);
                   cout<<"直接插入排序运行时间："<<sittime<<"秒"<<endl;
                  cout<<endl;
    			 break;
			}
    	    
    		case 2:{
				readData(num);
    			double bittime;
    			start=clock();
    			 BInsertSort(num);
    			 end=clock();
    			 bittime=double(end-start);
    			 bittime=bittime/CLOCKS_PER_SEC; 
    			  cout<<"折半插入排序结果:"<<endl; 
    			  FILE * f2=fopen("data2.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f2,"%d ",num[i]);
                          }
                  fclose(f2);
		          printData(num);
		          cout<<"折半插入排序运行时间："<<bittime<<"秒"<<endl;
		        cout<<endl;
    			 break;
			}
    		
    		case 3:{
    			readData(num);
    			double shittime;
    			 int dk;
				 cout<<"请输入首次希尔值：";
				 cin>>dk; 
				start=clock();
    			 ShellInsertSort(num,dk);
    			end=clock();
    			shittime=double(end-start);
    			 shittime=shittime/CLOCKS_PER_SEC; 
    		    cout<<"希尔排序结果:"<<endl;
    		    FILE * f3=fopen("data3.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f3,"%d ",num[i]);
                          }
                  fclose(f3);
    			 printData(num);
    			 cout<<"希尔排序运行时间："<<shittime<<"秒"<<endl;
    			cout<<endl;
    			 break;
			}
    		
			case 4:{
				readData(num);
				double bitime;
				start=clock();
    			BubbleSort(num);
    			end=clock();
    			bitime=double(end-start);
    			 bitime=bitime/CLOCKS_PER_SEC;
    			 FILE * f4=fopen("data4.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f4,"%d ",num[i]);
                          }
                  fclose(f4);
    			 printData(num);
    			 cout<<"冒泡排序运行时间："<<bitime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}	
			case 5:{
				readData(num);
				double qstime;
				start=clock();
    			 QuickSort(num,0,N-1);
    			end=clock();
    		    qstime=double(end-start);
    			 qstime=qstime/CLOCKS_PER_SEC;
    			 cout<<"快速排序结果:"<<endl;
    			 FILE * f5=fopen("data5.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f5,"%d ",num[i]);
                          }
                  fclose(f5);
    			 printData(num);
    			 cout<<"快速排序运行时间："<<qstime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}	
			case 6:{
				readData(num);
				double sstime;
				 
    			 SelectSort(num);
    			end=clock();
    		    sstime=double(end-start);
    			 sstime=sstime/CLOCKS_PER_SEC;
    			 cout<<"选择排序结果:"<<endl;
    			 FILE * f6=fopen("data6.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f6,"%d ",num[i]);
                          }
                  fclose(f6);
    			 printData(num);
    			 cout<<"选择排序运行时间："<<sstime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}
			
    		case 7:{
    			readData(num);
    			 double hstime;
				start=clock();
    		    Heapsort(num);
    			end=clock();
    		    hstime=double(end-start);
    			 hstime=hstime/CLOCKS_PER_SEC;
    			 cout<<"大根堆排序结果:"<<endl;
    			 FILE * f7=fopen("data7.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f7,"%d",num[i]);
                          }
                  fclose(f7);
    			 printData(num);
    			 cout<<"大根堆排序运行时间："<<hstime<<"秒"<<endl;
    		     cout<<endl;
    			 break;
			}
    		
    		case 8:{
				readData(num);
    			double mstime;
				start=clock();
    		     Mergesort(num,0,N-1);
    			end=clock();
    		    mstime=double(end-start);
    			 mstime=mstime/CLOCKS_PER_SEC;
    			 cout<<"归并排序结果:"<<endl;
    			 FILE * f8=fopen("data8.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f8,"%d ",num[i]);
                          }
                  fclose(f8);
    			 printData(num);
    			 cout<<endl;
    			 cout<<"归并排序运行时间："<<mstime<<"秒"<<endl;
    			 break;
			}
    		
		}
    } 
} 

二、算法结果展示（仅展示部分）

三、程序源代码

#include<iostream>
#include <cstring>
#include <stdio.h>
#include <fstream>
#include <stdlib.h>
#include <time.h>
using namespace std; 

int N; //随机产生数据的个数 

void writeData();//随机产生N个数存入txt文件 
int readData(int num[]) ;//读取txt文件中的数据存入数组num[] 
void printData(int num[]); //输出随机产生的N个数据
void menu();//菜单用于选择所需排序算法 

void SInsertSort(int num[]);//直接插入排序算法
void BInsertSort(int num[]);//折半插入排序算法 
void ShellInsertSort(int num[]);//希尔排序算法
void BubbleSort(int num[]);//起泡排序算法 
void QuickSort(int num[],int low,int high);//快速排序算法
void SelectSort(int num[]);//选择排序算法 
void InitHeap(int num[], int i, int j);//大根堆初始化算法
void Heapsort(int num[]);//大根堆排序算法 
void Msort(int num[],int low,int mid,int high); //归并排序中合并算法 
void Mergesort(int num[],int low,int high);//归并排序中拆分算法 

void writeData(){//随机产生N个数存入txt文件 
 FILE* fp=fopen("data.txt","w");
        for(int i=0;i<N;i++)
       {
          fprintf(fp,"%d ",rand());
      }
    fclose(fp);
} 
int readData(int num[]) //读取txt文件中的数据存入数组num[]
{
    FILE *fp;
    fp=fopen("data.txt","r");
    if (fp==NULL){
        fclose(fp);
        return 0;
    }
    else
    {
        for (int i=0; i<N;i++){
            fscanf(fp,"%d",&num[i]);
			}
        fclose(fp);
        return 1;
    }
}

void printData(int num[]) //打印数据 
{
    for(int i=0;i<N;i++)
    {
     cout<<num[i]<<"\t";
    }
    cout<<endl;
}

/*直接插入排序：将记录插入到已排好序的有序表中，
              从而得到一个新的、记录数增1的有序表*/
void SInsertSort(int num[]){
for(int i=1;i<N;i++){
	for(int j=i-1;j>=0;j--){
		if(num[j]>num[j+1]){
			swap(num[j],num[j+1]);
		}
	}
  }
} 

/*折半插入排序：顺序地把待排序的序列中的各个元素按其关键字的大小，
               通过折半查找插入到已排序的序列的适当位置。*/
void BInsertSort(int num[]){
   int mid,low,high,t,i,j;
   for(i=1;i<N;i++){
   	     t=num[i];
         low=0;
         high=i-1;
     	while(low<=high){
   	    	mid=(high+low)/2;
   	    	if(num[mid]>t){
   			    high=mid-1;
		    }
		    else{
			  low=mid+1;
		   }
	   }
	    for (j =i-1;j>=high+1;j--){//将num[high]之后的数据全部后移一位
	    		num[j+1] = num[j];
		}
            num[high+1] = t;//将关键字插入num[high+1]        
   }
   
        	
} 

/*希尔排序:先将整体待排序列分割成为若干个子序列分别进行直接插入排序，
    待整个序列中的记录“基本有序”时，再对整体进行一次直接插入排序 */ 
void ShellInsertSort(int num[],int dk){//dk选择的希尔数 
	 for(int id=dk;id>0;id--){
	 	for(int i=0;i<id;i++){
	 		for(int j=i+id;j<N;j+=id){
	 			if(num[j]<num[j-id]){
	 				int t=num[j];
	 				int n=j-id;
	 				while(n>=0&&num[n]>t){
	 					num[n+id]=num[n];
	 					n=n-id;
					 }
					 num[n+id]=t;
				 }
			 }
		 } 
	 } 
}

/* 起泡排序：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，
            则将两个记录交换一下，然后比较第二个和第三个关键字，以此类推 */
void BubbleSort(int num[]){
	int tag=0;//标志位 
	cout<<"请选择起泡方式：1、冒大泡，2、冒小泡"<<endl;
	cin>>tag; 
	int i,j;
	switch(tag)	{
		    case 1:
		    	for(i = 0;i<N;i++){
                    for( j =1;j<N-i;j++){
                       if(num[j-1]>num[j]) //冒大泡 
		         	    {
		         	        swap(num[j-1],num[j]);
		                }
                    }
                }
                cout<<"冒大泡排序结果:"<<endl; 
                break;
			case 2:
				for( i = 0;i<N;i++){
                    for( j =1;j<N-i;j++){
                       if(num[j-1]<num[j]) //冒小泡 
		               	{
		             	swap(num[j-1],num[j]);
		             	}
                    }
               }
                cout<<"冒小泡排序结果:"<<endl; 
               break;
           default:
              cout<<"输入错误！请重新输入！"<<endl;
             BubbleSort( num);
    }
} 

/*快速排序:通过一趟排序将待排序列分割为独立的两部分，其中一部分比关键字小，
       一部分比关键字大，然后对两部分继续进行快速排序，以达到整个待排序列有序*/ 
void QuickSort(int num[],int low,int high){
	if(low<high){	
	 int i=low;
	 int j=high;
	 int key=num[low];
     while(i<j){
     	while(i<j&&num[j]>key) {
		 j--;
		 }
        if(i<j){
        	num[i++]=num[j];
		}
		 while(i<j&&num[i]<key) {
		 i++;
		 }
		 if(i<j){
     		num[j--]=num[i]; 
	 }
	 }    
	 num[i]=key;
	 QuickSort(num,low,i-1);
	 QuickSort(num,i+1,high);
	 }	 
}
/*选择排序：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
          顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。*/ 
void SelectSort(int num[]){
   int min;
   for(int i=0;i<N;i++){
   	   min=i;
   	   for(int j=i+1;j<N;j++){
   	   	if(num[j]<num[min]){
   	   		min=j;
			  }
		  }
	 swap(num[i],num[min]);
   }
} 
/*堆排序： 1、初始化堆：根据数组构建大根堆； 
           2、将当前无序区的堆顶元素同该区间的最后一个记录交换，然后将新的无序区调整为新的大根堆*/
void InitHeap(int num[], int i, int j) {//初始化大根堆						
	int parent=i;										
	int lchild=2*i+1;//i的左孩子									
	while (lchild<j) {
		if (num[lchild]<num[lchild+1]&&lchild<j-1) {	//比较左右子节点 
			lchild++;
		}
		if (num[parent]<num[lchild]) {				
			swap(num[parent],num[lchild]);					
			parent=lchild;								
		}
        lchild=lchild * 2 + 1;								
	}
}
void Heapsort(int num[]) {												
	for (int i=N/2-1;i>= 0;i--) {							
		InitHeap(num,i,N);								
	}								
	for (int i=N-1;i>0;i--)
	{
		swap(num[0],num[i]);//堆顶元素与最后一个元素交换								
		InitHeap(num,0,i);//重新建堆 
}
}

/*归并排序：它分为拆分和合并两大部分，先拆后合。
          拆分：就是将一堆无序的数拆成单个，方便合并。
		  合并：就是将拆分好的数按照排序规则再拼凑起来。*/
void Msort(int num[],int low,int mid,int high){
	int temp[N];
	int l=low;
	int j=mid+1;
	int m=mid;
	int h=high;
		int i=low;
		  while(l<=m&&j<=h){
        if(num[l]>num[j])
            temp[i++] = num[j++] ;
        else
            temp[i++] = num[l++] ;
    }
    //将两边剩余元素加到temp的末尾 
    while(l<=m) 
        temp[i++] = num[l++] ;
    while(j<=h)
        temp[i++] = num[j++] ;

	for(i=low;i<=high;++i){
	num[i]=temp[i]; 
   }
}
void Mergesort(int num[],int low,int high){
	if(low<high){
	int mid=(low+high)/2;
	Mergesort(num,low,mid);//拆分 
	Mergesort(num,mid+1,high);
	Msort(num,low,mid,high);//合并 
	}
}

/*菜单：用于选择你需要的算法，并且将排序结果保存到txt文件中，
        并计算八种排序的上机运行程序所花费的时间，用于比较性能*/ 
void menu(){
	int num[N];
    int tag=0;
    while(tag!=9){
    	cout<<"$________$Menu$___________$"<<endl; 
	    cout<<" *****1-直接插入排序*****"<<endl;
	    cout<<" *****2-折半插入排序*****"<<endl;
	    cout<<" *****3-希尔排序*********"<<endl;
	    cout<<" *****4-起泡排序*********"<<endl;
	    cout<<" *****5-快速排序*********"<<endl;
	    cout<<" *****6-选择排序*********"<<endl;
	    cout<<" *****7-大根堆排序*******"<<endl;
	    cout<<" *****8-归并排序*********"<<endl;
	    cout<<" *****9-退出*************"<<endl;
	    cout<<"$_________$$$____________$"<<endl;
	    cout<<"   请输入你需要的操作：";
        cin>>tag; 
        double start,end;//开始时间，结束时间 
    	switch(tag){
    	    case 1:{
				readData(num);
    	    	double sittime;
    	    	 start=clock(); 
    			 SInsertSort(num);
    			 end=clock();
    			 sittime=double(end-start);
    			 sittime=sittime/CLOCKS_PER_SEC; 
    			 cout<<"直接插入排序结果："<<endl;
    			 FILE * f1=fopen("data1.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f1,"%d ",num[i]);
                          }
                  printData(num);
                  fclose(f1);
                   cout<<"直接插入排序运行时间："<<sittime<<"秒"<<endl;
                  cout<<endl;
    			 break;
			}
    	    
    		case 2:{
				readData(num);
    			double bittime;
    			start=clock();
    			 BInsertSort(num);
    			 end=clock();
    			 bittime=double(end-start);
    			 bittime=bittime/CLOCKS_PER_SEC; 
    			  cout<<"折半插入排序结果:"<<endl; 
    			  FILE * f2=fopen("data2.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f2,"%d ",num[i]);
                          }
                  fclose(f2);
		          printData(num);
		          cout<<"折半插入排序运行时间："<<bittime<<"秒"<<endl;
		        cout<<endl;
    			 break;
			}
    		
    		case 3:{
    			readData(num);
    			double shittime;
    			 int dk;
				 cout<<"请输入首次希尔值：";
				 cin>>dk; 
				start=clock();
    			 ShellInsertSort(num,dk);
    			end=clock();
    			shittime=double(end-start);
    			 shittime=shittime/CLOCKS_PER_SEC; 
    		    cout<<"希尔排序结果:"<<endl;
    		    FILE * f3=fopen("data3.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f3,"%d ",num[i]);
                          }
                  fclose(f3);
    			 printData(num);
    			 cout<<"希尔排序运行时间："<<shittime<<"秒"<<endl;
    			cout<<endl;
    			 break;
			}
    		
			case 4:{
				readData(num);
				double bitime;
				start=clock();
    			BubbleSort(num);
    			end=clock();
    			bitime=double(end-start);
    			 bitime=bitime/CLOCKS_PER_SEC;
    			 FILE * f4=fopen("data4.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f4,"%d ",num[i]);
                          }
                  fclose(f4);
    			 printData(num);
    			 cout<<"冒泡排序运行时间："<<bitime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}	
			case 5:{
				readData(num);
				double qstime;
				start=clock();
    			 QuickSort(num,0,N-1);
    			end=clock();
    		    qstime=double(end-start);
    			 qstime=qstime/CLOCKS_PER_SEC;
    			 cout<<"快速排序结果:"<<endl;
    			 FILE * f5=fopen("data5.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f5,"%d ",num[i]);
                          }
                  fclose(f5);
    			 printData(num);
    			 cout<<"快速排序运行时间："<<qstime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}	
			case 6:{
				readData(num);
				double sstime;
				 
    			 SelectSort(num);
    			end=clock();
    		    sstime=double(end-start);
    			 sstime=sstime/CLOCKS_PER_SEC;
    			 cout<<"选择排序结果:"<<endl;
    			 FILE * f6=fopen("data6.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f6,"%d ",num[i]);
                          }
                  fclose(f6);
    			 printData(num);
    			 cout<<"选择排序运行时间："<<sstime<<"秒"<<endl;
    			 cout<<endl;
    			 break;
			}
			
    		case 7:{
    			readData(num);
    			 double hstime;
				start=clock();
    		    Heapsort(num);
    			end=clock();
    		    hstime=double(end-start);
    			 hstime=hstime/CLOCKS_PER_SEC;
    			 cout<<"大根堆排序结果:"<<endl;
    			 FILE * f7=fopen("data7.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f7,"%d",num[i]);
                          }
                  fclose(f7);
    			 printData(num);
    			 cout<<"大根堆排序运行时间："<<hstime<<"秒"<<endl;
    		     cout<<endl;
    			 break;
			}
    		
    		case 8:{
				readData(num);
    			double mstime;
				start=clock();
    		     Mergesort(num,0,N-1);
    			end=clock();
    		    mstime=double(end-start);
    			 mstime=mstime/CLOCKS_PER_SEC;
    			 cout<<"归并排序结果:"<<endl;
    			 FILE * f8=fopen("data8.txt","w");
                     for(int i=0;i<N;i++)
                   {
                  fprintf(f8,"%d ",num[i]);
                          }
                  fclose(f8);
    			 printData(num);
    			 cout<<endl;
    			 cout<<"归并排序运行时间："<<mstime<<"秒"<<endl;
    			 break;
			}
    		
		}
    } 
} 

 int main(){
 	cout<<"请输入随机数个数："<<endl;
 	cin>>N;
 	writeData(); 
    int data[N];
    readData(data);
    cout<<"随机产生的N个数据如下："<<endl ;
    printData(data);
    menu();
 }
 

希望各位大佬不吝赐教，做一个开心的代码狗。