课 程 设 计 说 明 书
课程名称： 数据结构课程设计 设计题目： 多种排序
院 系： 计算机科学与信息工程学院 学生姓名： 张浩 学 号： 130xxxxxxxx 专业班级： 13级网络工程 指导教师：
20xx年 6 月 23日
课 程 设 计 任 务 书
多种排序
摘 要：本次课程设计所要求的排序方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序，基本上将我们学习过的排序方法都囊括在内，可以说这次课程设计是对我们学过的排序算法的一个总结和对比。通过实验中各种排序方法所用的时间对比，可以让我们对每种排序方法的性能有一个清晰的认识，有利于我们以后在做某些程序时更好的选择最好的排序方法。
关键词：(1)六种排序 ①插入排序 ②希尔排序 ③起泡排序 ④快速排序
⑤选择排序 ⑥堆排序
(2) 排序方法的性能
关键问题:
核心问题: 排列组合
数据模型（逻辑结构）：30000个随机数
存储结构: 保存在不同的文件
核心算法: 直接插入、直接选择、冒泡、快速排序、堆排序的算法
输入数据: 初始化数组：rand()%50000+1
输出数据：排序内容到文件，排序所用时间
目 录
1. 设计背景?????????????????????5
1.1 总设计?????????????????????5
2.设计方案?????????????????????5
2.1设计思想????????????????????5
2.2主要思想和流程图????????????????6 3方案实施?????????????????????7
3.1程序的实现???????????????????7
3.2主要源代码及说明????????????????7 4结果与结论????????????????????20
4.1运行主界面???????????????????20
4.2各种排序方法运行结果??????????????20
4.3 运行结论????????????????????24 5收获与致谢????????????????????24 6参考文献?????????????????????24 7 附件 ?????????????????????24
1. 设计背景
1.1总设计
分别实现直接插入排序、希尔排序、直接选择排序、冒泡排序、快速排序、堆排序的算法。从时间的角度来分析各种排序的性能。通过测试多组数据来掌握各种排序的方法及适用场合，并能在解决实际问题灵活运用。在编写代码的时候，有以下几个问题：
（1）建立一个主函数，在主函数中要有菜单界面，和输入功能键相应执行的功能。并且要求能循环使用系统。
（2）分别实现直接插入排序、希尔排序、直接选择排序、冒泡排序、快速排序、堆排序的算法。
（3）通过冒泡排序法来测试每组数据用那种排序算法最优。
2.设计方案
2.1 设计思想
建立一个主函数，在主函数中要有菜单界面，和输入功能键相应执行的功能。并且要求能循环使用系统。分别实现直接插入、直接选择、冒泡、快速排序、堆排序的算法。
（1）直接插入排序的基本思想是基于插入，开始假定第一个记录有序，然后从第二个记录开始，依次插入到前面有序的子文件中。即将记录a[i](2<=i<=n)插入到有序子序列a[1..i-1]中，使记录的有序序列从a[1..i-1]变为a[1..i] ，最终使整个文件有序。共进行n-1趟插入。最坏时间复杂度是0(n2)，平均时间复杂度是0(n2)，空间复杂度是O(1)，是稳定排序。
（2）希尔排序的基本思想是基于分组，先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
（3）直接选择排序的基本思想是基于选择，开始有序序列长度为零，第i(1<=i<n)趟简单选择排序是，从无序序列a[i..n]的n-i+1记录中选出关键字最小的记录，和第i个记录交换，使有序序列逐步扩大，最后整个文件有序。共进行n-1趟选择。最坏时间复杂度是0(n2)，平均时间复杂度是0(n2)，空间复杂度是O(1)，是不稳定排序。
(4)冒泡排序：首先将第一个记录的关键字和第二个记录的关键字进行比较，若为逆序，则将两个记录交换，然后比较第二个记录和第三个记录的关键字。依此类推，直到第N-1和第N个记录的关键字进行过比较为止。上述为第一趟排序，其结果使得关键字的最大
纪录被安排到最后一个记录的位置上。然后进行第二趟起泡排序，对前N-1个记录进行
同样操作。一共要进行N-1趟起泡排序。
(5)快速排序思想：从待排序列中任取一个元素 (例如取第一个) 作为中心，所有比它
小的元素一律前放，所有比它大的元素一律后放，形成左右两个子表；然后再对各子表
重新选择中心元素并依此规则调整，直到每个子表的元素只剩一个。此时便为有序序列
了。
(6)堆排序基本思想是：堆是n个元素的序列，先建堆，即先选得一个关键字最大或最
小的记录，然后与序列中最后一个记录交换，之后将序列中前n-1记录重新调整为堆（调
堆的过程称为“筛选”），再将堆顶记录和当前堆序列的最后一个记录交换，如此反复直
至排序结束。优点是在时间性能与树形选择排序属同一量级的同时，堆排序只需要一个
记录大小供交换用的辅助空间，调堆时子女只和双亲比较。避免了过多的辅助存储空间
及和最大值的比较。
2.2 主要算法和流程图
3. 方案实施
3.1 程序的实现
程序实现时应考虑的问题
3.2 主要源代码及说明
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>
#include <time.h>
#define N 10000
void Wrong()
{
printf("\n=====>按键错误!\n");
getchar();
}
void Disp(int a[])
{
int i;
system("cls");
for(i=0;i<N;i++)
{
if((i-1)%10==9)
printf("\n");
printf("%-7d",a[i]);
}
}
void InsertSort(int a[],int p) //插入排序 {
int i,j,temp;
for(i=1;i<N;i++)
{
temp=a[i];
for(j=i;j>0&&a[j-1]>temp;j--) a[j]=a[j-1];
a[j]=temp;
}
}
void shellSort(int a[],int p) //希尔排序 {
int i,j,temp;
for(i=p;i<N;i++)
{
if(a[i]<a[i-p])
{
temp=a[i];
for(j=i-p;j>=0&&(temp<a[j]);j=j-p) a[j+p]=a[j];
a[j+p]=temp;
}
}
}
void SelectSort(int a[],int p) //选择排序 {
int i,j,k;
for(i=0;i<N-1;i++)
{
k=i;
for(j=i+1;j<N;j++)
if(a[j]<a[k])
k=j;
if(k!=i)
{
int temp;
temp=a[k];
a[k]=a[i];
a[i]=temp;
}
}
}
void BubbleSort(int a[],int p) /*冒泡排序算法*/ {
int i,j,temp;
for (i=0;i<N-1;i++)
{
for (j=N-1;j>i;j--) /*比较,找出本趟最小关键字的记录*/ if (a[j]<a[j-1])
{
temp=a[j]; /*进行交换,将最小关键字记录前移*/ a[j]=a[j-1];
a[j-1]=temp;
}
}
}
void creatheap(int a[],int i,int n) //创建堆 {
int j;
int t;
t=a[i];
j=2*(i+1)-1;
while(j<=n)
{
if((j<n)&&(a[j]<a[j+1])) j++; if(t<a[j]) { a[i]=a[j]; } else j=n+1; i=j; j=2*(i+1)-1;
}
a[i]=t;
}
void heapsort(int a[],int n,int p) //堆排序 {
int i;
int t;
for(i=n/2-1;i>=0;i--)
creatheap(a,i,n-1);
for(i=n-1;i>=1;i--)
{
}
void quicksort(int a[],int n,int p)
{
int i,j,low,high,temp,top=-1;
struct node
{
int low,high;
}st[N];
top++;
st[top].low=0;st[top].high=n-1;
while(top>-1)
{ low=st[top].low;high=st[top].high; top--;
i=low;j=high;
if(low<high) t=a[0]; a[0]=a[i]; a[i]=t; creatheap(a,0,i-1);}
{ temp=a[low];
while(i!=j)
{ while(i<j&&a[j]>temp)j--;
if(i<j){a[i]=a[j];i++;}
while(i<j&&a[i]<temp)i++;
if(i<j){a[j]=a[i];j--;}
}
a[i]=temp;
top++;st[top].low=low;st[top].high=i-1; top++;st[top].low=i+1;st[top].high=high; }
}
}
double TInsertSort(int a[],int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
InsertSort(b,p);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;
if(p!=7)
{Disp(b);getchar();}
printf("\n用直接插入排序法用的时间为%f秒；",time); FILE *fp;
fp=fopen("直接插入排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp);
return(time);
}
double TShellSort(int a[],int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
InsertSort(b,p);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;
if(p!=7)
{Disp(b);getchar();}
printf("\n希尔排序法用的时间为%f秒；",time);
FILE *fp;
fp=fopen("希尔排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp);
return(time);
}
double TSelectSort(int a[],int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
SelectSort(b,p);
if(p!=7)
{Disp(b);getchar();}
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;
printf("\n用直接选择排序法用的时间为%f秒；",time); FILE *fp;
fp=fopen("直接选择排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp);return(time);
}
double TBubbleSort(int a[],int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
BubbleSort(b,p);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;
if(p!=7)
{Disp(b);getchar();}
printf("\n用冒泡排序法用的时间为%f秒；",time);
FILE *fp;
fp=fopen("冒泡排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp);return(time);
}
double Theapsort(int a[],int n,int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
heapsort(b,N,p);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart; time/=m_liPerfFreq.QuadPart;
if(p!=7)
{Disp(b);getchar();}
printf("\n用堆排序法用的时间为%f秒；",time);
FILE *fp;
fp=fopen("堆排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp);return(time);
}
double Tquicksort(int a[],int n,int p)
{
int i;
int b[N];
for(i=0;i<N;i++)
b[i]=a[i];
LARGE_INTEGER m_liPerfFreq={0};
QueryPerformanceFrequency(&m_liPerfFreq);
LARGE_INTEGER m_liPerfStart={0};
QueryPerformanceCounter(&m_liPerfStart);
quicksort(b,N,p);
LARGE_INTEGER liPerfNow={0};
QueryPerformanceCounter(&liPerfNow);
double time=liPerfNow.QuadPart - m_liPerfStart.QuadPart;
time/=m_liPerfFreq.QuadPart;
if(p!=7)
{Disp(b);getchar(); }
printf("\n用快速排序法用的时间为%f秒；",time);
FILE *fp;fp=fopen("快速排序.txt","w");
for(i=0;i<N;i++)
fprintf(fp,"%d ",b[i]);
fclose(fp); return(time);
}
void BubleSort(double a[]) //时间数组的冒泡排序
{
int i,j;
double temp;
for(i=1;i<7;i++)
{
for(j=5;j>=i;j--)
if(a[j+1]<a[j])
{
temp=a[j+1];
a[j+1]=a[j];
a[j]=temp;
}
}
void menu()
{
printf(" ************** 欢迎来到排序系统! ****************\n"); printf(" ************** (1)---直接插入排序 ******************\n"); printf(" ************** (2)---希尔排序 ******************\n"); printf(" ************** (3)---直接选择排序 ******************\n"); }
printf(" ************** (4)---冒泡排序 ******************\n"); printf(" ************** (5)---快速排序 ******************\n"); printf(" ************** (6)---堆排序 ******************\n"); printf(" ************** (7)---时间效率比较 ******************\n"); printf(" ************** (8)---显示随机数 ******************\n"); printf(" ************** (0)---退出 ******************\n"); printf(" ****************************************************\n"); printf("\n====>请在上述序号中选择一个并输入:");
}
void main()
{
int i,p,a[N];
srand((int)time(NULL)); /*随机种子*/
for(i=0;i<N;i++)
a[i]=rand()%50000+1;
while(1)
{
system("cls");
menu();
scanf("%d",&p);
if(p==0)
{
printf("=====>谢谢使用!\n");
getchar();
break;
}
double TIMES[6],TIMES1[6];//时间数组
switch(p)
{
case 1:TInsertSort(a,p);printf("\n请按任意键继续...");getchar();break;
case 2:TShellSort(a,p);printf("\n请按任意键继续...");getchar();break; case 3:TSelectSort(a,p);printf("\n请按任意键继续...");getchar();break; case 4:TBubbleSort(a,p);printf("\n请按任意键继续...");getchar();break; case 5:Tquicksort(a,N,p);printf("\n请按任意键继续...");getchar();break; case 6:Theapsort(a,N,p);printf("\n请按任意键继续...");getchar();break; case 7:system("cls");
TIMES1[1]=TIMES[1]=TInsertSort(a,p);
TIMES1[2]=TIMES[2]=TShellSort(a,p);
TIMES1[3]=TIMES[3]=TSelectSort(a,p);
TIMES1[4]=TIMES[4]=TBubbleSort(a,p);
TIMES1[5]=TIMES[5]=Tquicksort(a,N,p);
TIMES1[6]=TIMES[6]=Theapsort(a,N,p);getchar();
BubleSort(TIMES);
printf("\n\n");
{
printf("排序这组数据两种较快的排序法分别是：\n");
if(TIMES[1]==TIMES1[1]) printf("直接插入排序:%f秒!\n",TIMES[1]); if(TIMES[1]==TIMES1[2]) printf("希尔排序:%f秒!\n",TIMES[1]);
if(TIMES[1]==TIMES1[3]) printf("直接选择排序:%f秒!\n",TIMES[1]);
if(TIMES[1]==TIMES1[4]) printf("冒泡排序:%f秒!\n",TIMES[1]); if(TIMES[1]==TIMES1[5]) printf("快速排序:%f秒!\n",TIMES[1]); if(TIMES[1]==TIMES1[6]) printf("堆排序:%f秒!\n",TIMES[1]); if(TIMES[1]!=TIMES[2]) {
if(TIMES[2]==TIMES1[1]) printf("直接插入排序:%f秒!\n",TIMES[2]); if(TIMES[2]==TIMES1[2]) printf("希尔排序%f秒!\n",TIMES[2]);
if(TIMES[2]==TIMES1[3]) printf("直接选择排序%f秒!\n",TIMES[2]); if(TIMES[2]==TIMES1[4]) printf("冒泡排序%f秒!\n",TIMES[2]); if(TIMES[2]==TIMES1[5]) printf("快速排序%f秒!\n",TIMES[2]); if(TIMES[2]==TIMES1[6]) printf("堆排序%f秒!\n",TIMES[2]);
}
} printf("\n请按任意键继续...");srand((int)time(NULL));
for(i=0;i<N;i++) {a[i]=rand()%10000+1;} getchar();break;
case 8:Disp(a);FILE *fp;fp=fopen("随机数.txt","w");
for(i=0;i<N;i++)fprintf(fp,"%d ",a[i]);fclose(fp);getchar();printf("\n请按任意键继续...");getchar();break;
default:Wrong();printf("\n请按任意键继续...");getchar();break;
}
}
}
4. 结果与结论
4.1 运行主界面
4.2 各种排序方法运行结果
1.直接排序结果如图1
图1 直接排序结果
2.希尔排序结果如图
2
图2 希尔排序结果
3.直接选择排序结果如图
3
图3 直接选择排序结果
4.冒泡排序结果如图
4
图4 冒泡排序结果
5.快速排序结果如图
5
图5 快速排序结果
6.堆排序结果如图
6
图6 堆排序结果
4.3 运行结论
运行结果如图
7
图7 运行结果
由上述运行结果看得到：对同一组数进行排序，快速排序和堆排序所用的时间最少。
5. 收获与致谢
通过本次课程设计，我们更加熟悉了插入排序、希尔排序这两种排序，让我们能更加熟悉其算法及各自的功能：而且本次课程设计让我们体会到了团队合作的重要性。感谢老师对我们的辛勤教育使我们学会了关于数据结构的知识，让我们在程序设计方面可以有更长远的发展。
6. 参考文献
[1] 严蔚敏，吴伟民编著. 数据结构(C语言版).清华大学出版社，2007
[2] 谭浩强编著. C程序设计教程.清华大学出版社，2007.7
[3] 刘振安，孙忱，刘燕君编著.C程序设计课程设计.机械工业出版社，2004.9
7. 附件
多种排序.cpp；多种排序.dsp；多种排序.dsw；多种排序.opt；多种排序NCB文件； 多种排序HTML文档；txt文本文档
