多种排序方法及验证

编译环境：Microsoft Visual C++2010学习版
参考教材：数据结构：C语言版/严蔚敏，李冬梅，吴伟民编
备注：本文留作作者自用，如有错误敬请指出

内容描述

第一步，利用程序随机生成10000个在0-9999之间的数字，将10000个数据保存在数组A中
第二步，分别编写直接插入排序、折半插入排序、希尔排 序、冒泡排序、快速排序、简单选择排序、 归并排序算法程序（每个算法用函数封装）
第三步，调用每个排序方法对数组A进行排序，同时计算消耗时间，并输出。

实现代码

#include<iostream>
#include<cstdlib>
#include <time.h>
using namespace std;
#define MAXSIZE 10000
typedef int KeyType;
int i,j,low,high,m,k,flag,t,pivotkey;
typedef struct{
  KeyType key;
}RedType;//记录类型
RedType S[MAXSIZE+1];
typedef struct{
  RedType a[MAXSIZE+1];
  int length;
}SqList;//顺序表类型
void InsertSort(SqList &L){  //直接插入排序
	for( i=2;i<L.length;++i){
		if(L.a[i].key<L.a[i-1].key){
            L.a[0]=L.a[i];
			L.a[i]=L.a[i-1];
			for(j=i-2;L.a[0].key<L.a[j].key;--j){
               L.a[j+1]=L.a[j];			
			}
			L.a[j+1]=L.a[0];
		}
	}
}
//**********************************
void BInsertSort(SqList &L){   //折半插入排序
	for(i=2;i<=L.length;++i){
       L.a[0]=L.a[i];
	   low=1;
	   high=i-1;
	   while(low<=high){
          m=(low+high)/2;
		  if(L.a[0].key<L.a[m].key)
			  high=m-1;
		  else low=m+1;
	   }
	   for(j=i-1;j>=high+1;--j){
	      L.a[j+1]=L.a[j];
	   }
	   L.a[high+1]=L.a[0];
	}
}
//*********************************
void ShellInsert(SqList &L,int dk){  //希尔排序
	for(i=dk+1;i<=L.length;++i){
		if(L.a[i].key<L.a[i-dk].key){
		   L.a[0]=L.a[i];
		   for(j=i-dk;j>0 && L.a[0].key<L.a[j].key;j-=dk){
              L.a[j+dk]=L.a[j];		   
		   }
		   L.a[j+dk]=L.a[0];
		}
	}
}
void ShellSort(SqList &L){
	int dt[]={200,100,50,10,5,3,1};
	t=sizeof(dt)/sizeof(*dt);//求数组dt长度
    for(k=0;k<t;++k)
		ShellInsert(L,dt[k]);
}
//*********************************
void BubbleSort(SqList &L){   //冒泡排序
   m=L.length-1;
   flag=1;
   while(m>0 && flag==1){
      flag=0;
	  for(j=1;j<=m;++j){
		  if(L.a[j].key>L.a[j+1].key){
		     flag=1;
			 t=L.a[j].key;
			 L.a[j].key=L.a[j+1].key;
			 L.a[j+1].key=t;
		  }
	  }
	  --m;
   }
}
//*********************************
int Partition(SqList &L,int low,int high){   //快速排序
    L.a[0]=L.a[low];
	pivotkey=L.a[low].key;
	while(low<high){
	   while(low<high && L.a[high].key>=pivotkey)
		   --high;
	   L.a[low]=L.a[high];
	   while(low<high && L.a[low].key<=pivotkey)
		   ++low;
	   L.a[high]=L.a[low];
	}
	L.a[low]=L.a[0];
	return low;
}
void Qsort(SqList &L,int low,int high){
	if(low<high){
	   m=Partition(L,low,high);
	   Qsort(L,low,m-1);//对左子表递归排序
	   Qsort(L,m+1,high);//对右子表递归排序
	}
}
void QuickSort(SqList &L){
	Qsort(L,1,L.length);
}
//*********************************
void SelectSort(SqList &L){   //简单选择排序
	for(i=1;i<L.length;++i){
	   k=i;
	   for(j=i+1;j<=L.length;++j){
	      if(L.a[j].key<L.a[k].key)
			  k=j;
	   }
	   if(k!=i){
		  t=L.a[i].key;
		  L.a[i].key=L.a[k].key;
		  L.a[k].key=t;
	   }
	}
}
//*********************************
//用算法8.10 相邻两个有序子序列的归并
void Merge(RedType R[],RedType T[],int low,int mid,int high)
{ 
   //将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high] 
	int i,j,k;
	i=low; j=mid+1;k=low; 
    while(i<=mid&&j<=high)
	{                 	
		//将R中记录由小到大地并入T中 
		if(R[i].key<=R[j].key) T[k++]=R[i++]; 
        else T[k++]=R[j++]; 
	} 
	while(i<=mid)                            		//将剩余的R[low..mid]复制到T中 
		T[k++]=R[i++];                 
	while(j<=high)                           		//将剩余的R[j.high]复制到T中 
		T[k++]=R[j++];                       
}//Merge 

void MSort(RedType R[],RedType T[],int low,int high)
{ 
	//R[low..high]归并排序后放入T[low..high]中 
	int mid;
	RedType *S=new RedType[MAXSIZE];
    if(low==high) T[low]=R[low]; 
    else
	{ 
		mid=(low+high)/2;       					//将当前序列一分为二，求出分裂点mid 
        MSort(R,S,low,mid);							//对子序列R[low..mid] 递归归并排序，结果放入S[low..mid] 
        MSort(R,S,mid+1,high);						//对子序列R[mid+1..high] 递归归并排序，结果放入S[mid+1..high] 
        Merge(S,T,low,mid,high);					//将S[low..mid]和S [mid+1..high]归并到T[low..high]  
    }//else 
}// MSort 
 
void MergeSort(SqList &L)
{ 
	//对顺序表L做归并排序 
    MSort(L.a,L.a,1,L.length); 
}//MergeSort 
void print(SqList &L){  //打印
	for(i=1;i<MAXSIZE+1;++i){
       cout<<L.a[i].key<<" ";
	   if(i%15==0)
		   cout<<endl;
	}
}
int main(){
	SqList L;
	L.length=MAXSIZE;
	srand((unsigned)time(NULL)); 
	for( i=1;i<MAXSIZE+1;++i){  //生成MAXSIZE个随机数作为关键字的值
	   L.a[i].key=rand()%MAXSIZE;
	}
time_t c_start, c_end;
c_start = clock();    // 单位为ms
//加入排序函数;
InsertSort(L);
c_end   = clock();
//!<difftime（time_t, time_t）返回两个time_t变量间的时间间隔，即时间差
printf("直接插入排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  //生成MAXSIZE个随机数作为关键字的值
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
BInsertSort(L);
c_end   = clock();
printf("折半插入排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
ShellSort(L);
c_end   = clock();
printf("希尔排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
BubbleSort(L);
c_end   = clock();
printf("冒泡排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
	QuickSort(L);
c_end   = clock();
printf("快速排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
	SelectSort(L);
c_end   = clock();
printf("简单选择排序消耗 %f ms \n",difftime(c_end,c_start)); 
for( i=1;i<MAXSIZE+1;++i){  
	   L.a[i].key=rand()%MAXSIZE;
	}
c_start = clock(); 
MergeSort(L);
c_end   = clock();
printf("归并排序消耗 %f ms \n",difftime(c_end,c_start));
//print(L);
	system("pause");
    return 0;
}

标签：多种,clock,mid,high,low,key,排序,方法
来源： https://blog.csdn.net/weixin_51614848/article/details/122268149