一、实验目的：

比较至少4种排序算法的执行效率。已学过的算法：起泡排序、选择排序、插入排序、shell排序，归并排序、快速排序等。

二、实验要求：

1、从中选择至少4中排序算法，写成独立的函数进行调用。

2、参与排序的数据不少于5000个，要求用数据文件存储随机产生的数据。

3、要求在main()函数中调用以上函数，并输出各排序算法所用时间。

三、问题描述：

通过至少四种排序算法设计，功能实现，计算出完成随机生成的至少5000个数所需要的时间，并比较各种算法的效率。

四、算法分析：

随机数存入文件：函数void RandToFile(int *a);通过rand()函数生成随机数，再利用文件指针*fp将生成的随机数所在的数组存入文件data.txt。

从文件读取随机数：函数void ReadFromFile(int a[]);通过文件指针*fp读文件data.txt中的数组用于后续运算。

快速排序：函数void Quick_Sort(int *a,int low,int high);采用递归思想将数组以基数为中间大小分割成两部分，在对所分割的每部分采用递归方法分割，知道每部分只有一个元素，对每个单位进行排序。快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n2)

插入排序：函数void Insert_Sort(int *a,int n);假设设定的数组的前n（n>=2）个数已是有序，将第n个数插入到该有序序列中，并使之有序。如此循环反复，知道数组全部排列完成。直接插入排序是稳定的。算法时间复杂度O(n2)--[n的平方]

冒泡排序：函数void Bubble_Sort(int *a,int n);在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方]

希尔排序：函数void Shell_Sort(int *a,int n);算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。

希尔排序是不稳定的。

选择排序：函数void Select_Sort(int *a,int n);在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

选择排序是不稳定的。算法复杂度O(n2)--[n的平方]

主函数：在主函数内，首先调用随机数生成并存入文件的函数，在调用从文件读取数据的函数，然后，通过包含头文件<time.h>调用时钟函数clock()记录开始执行时间和结束时间，相减得出执行时间并显示在显示器上。在主函数内，可通过修改常变量N的值生成不同个数和不同范围的随机数，已验证执行时间的精确性。

五、代码：

1.随机数存入文件（void RandToFile(int *a)）

//生成N个小于N的随机数，存入数组a

void RandToFile(int *a)

{

srand( (unsigned)time( NULL ) );  //初始化随机数

     for(int i=0;i<N;i++)  

{ 

a[i]=(int)rand()%N; 

}

FILE *fp;

if((fp=fopen("data.txt","w"))==NULL)

{

printf("\nerror on open data.txt!");

getch();

exit(1);

}

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

fprintf(fp,"%1d\n",a[i]);

fclose(fp);

}

2.从文件读取数据(void ReadFromFile(int a[]))

void ReadFromFile(int a[])

{

int i=0;

FILE *fp;

if((fp=fopen("data.txt","r"))==NULL)

{

printf("file read error!");

exit(1);

}

while(!feof(fp))

{

fscanf(fp,"%d",&a[i++]);

}

fclose(fp);

}

3.快速排序(void Quick_Sort(int *a,int low,int high))

void Quick_Sort(int *a,int low,int high)

{

int Partition(int *a,int low,int high);

int mid;

if(low<high)

{

mid=Partition(a,low,high);

Quick_Sort(a,low,mid-1);/*递归调用*/

Quick_Sort(a,mid+1,high);

}

}

int Partition(int *a,int low,int high)  

{   

int mid,temp;

int i=low,j=high+1;

mid=a[low];   

while(i < j)   

{    

while((a[++i] < mid)&&i<high);

while(a[--j]>mid);

if(i>=j)break;

temp=a[i];

a[i]=a[j];

a[j]=temp;

}   

a[low]=a[j];   

return j;    

}

4.插入排序(void Insert_Sort(int *a,int n))

void Insert_Sort(int *a,int n)

{

int i,j,temp;

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

{

temp=a[i];/*操作当前元素，先保存在其它变量中*/

for(j=i-1;j>=0&&a[j]>temp;j--)

{

a[j+1]=a[j];/*一边找一边移动元素*/

}

a[j+1]=temp;

}

}

5.冒泡排序(void Bubble_Sort(int *a,int n))

void Bubble_Sort(int *a,int n)

{ 

int i,j,temp; 

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

for(j=0;j<n-i;j++) /*注意循环的上下限*/ 

if(a[j]>a[j+1]) 

{  

temp=a[j]; 

a[j]=a[+1]; 

a[j+1]=temp; 

}

}

6.希尔排序(void Shell_Sort(int *a,int n))

void Shell_Sort(int *a,int n)

{

int gap,i,j,temp;

for(gap=n/2;gap>0;gap/=2)/*设置排序的步长，步长gap每次减半*/

{

for(i=gap;i<n;i++)/*定位到每一个元素*/

{

for(j=i-gap;(j>=0)&&(a[j]>a[j+gap]);j-=gap)/*比较相距

gap远的两个元素的大小，根据排序方向决定如何调换*/

{

temp=a[j];a[j]=a[j+gap];a[j+gap]=temp;

}

}

}

}

7.选择排序(void Select_Sort(int *a,int n))

void Select_Sort(int *a,int n)

{

int i,j,k,temp;

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

{

k=i;

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

{

if(a[k]>a[j]) //a[k]若大于a[j]将j赋值给k;

k=j;

}

temp=a[i];

a[i]=a[k];

a[k]=temp;

}

}

8.主函数

void main()

{

printf("===============各种排序所耗的时间==============\n");

int a[N];

int low=0;

clock_t begin,stop;

RandToFile(a);

ReadFromFile(a);

double exeTime_Quick,exeTime_Insert,exeTime_Bubble,exeTime_Shell,exeTime_Select;

//测试快速排序时间

begin=clock();//开始记录时间

Quick_Sort(a,low,N);

stop=clock();//时间记录完成

exeTime_Quick=(double)(stop-begin)/CLOCKS_PER_SEC;

printf( "快速排序%d个整数耗时 %f 秒\n",N,exeTime_Quick); 

//测试插入排序时间

begin=clock();

Insert_Sort(a,N);

stop=clock();

exeTime_Insert=(double)(stop-begin)/CLOCKS_PER_SEC;

printf( "插入排序%d个整数耗时 %f 秒\n",N,exeTime_Insert); 

//测试冒泡排序时间

begin=clock();

Bubble_Sort(a,N);

stop=clock();

exeTime_Bubble=(double)(stop-begin)/CLOCKS_PER_SEC;

printf( "冒泡排序%d个整数耗时 %f 秒\n",N,exeTime_Bubble); 

//测试希尔排序时间

begin=clock();

Shell_Sort(a,N);

stop=clock();

exeTime_Shell=(double)(stop-begin)/CLOCKS_PER_SEC;

printf( "希尔排序%d个整数耗时 %f 秒\n",N,exeTime_Shell); 

//测试选择排序时间

begin=clock();

Select_Sort(a,N);

stop=clock();

exeTime_Select=(double)(stop-begin)/CLOCKS_PER_SEC;

printf( "选择排序%d个整数耗时 %f 秒\n",N,exeTime_Select); 

printf("Input a char To end!");

getchar();//等待输入字符，不让窗口关闭

}

六、调试及运行：

1.当生成50000个随机数为参数时调试效果如下

2.当生成100000个随机数为参数时调试效果如下：

3.生成的随机数存入文件data.txt如下：

七、实验总结

通过这次算法实验，首先，我对各种排序算法的分类有了一定了解，也巩固了这些算法的基本原理；然后，在编程当中少不了算法的设计和分析，这个实验的难度让我感觉到了自身理论知识储备的不足；最后，我认为做这次实验的目的不仅仅是得到各种排序算法效率的比较，更重要的是让我们理解算法里面的思维模式，知道各种排序算法的基本原理比知道它们的效率更重要。