几种常见的排序算法的实现与性能分析数据结构课程设计报告.docx
《几种常见的排序算法的实现与性能分析数据结构课程设计报告.docx》由会员分享，可在线阅读，更多相关《几种常见的排序算法的实现与性能分析数据结构课程设计报告.docx（38页珍藏版）》请在冰豆网上搜索。
几种常见的排序算法的实现与性能分析数据结构课程设计报告
1问题描述
设计一个测试程序比较起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法的关键字比较次数和移动次数以取得直观感受。
待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：
关键字参加比较次数和关键字的移动次数（关键字交换记为3次移动）。
最后输出比较结果。
2需求分析
当今社会，我们知道是信息化时代，那么排序算法对于计算机信息处理很重要，一个好的排序不仅可以使信息查找的效率提高，而且还直接影响着计算机的工作效率。
目前，最常见的排序算法有直接排序法、希尔排序法、冒泡排序法、选择排序法、快速排序法、堆排序等算法。
这些排序算法各有自己的优缺点，不同的排序算法适应不同的情况。
就算法的整体性能而言,目前很难提出一种适应所有的排序场合的最好的排序算法，每种算法都有自己不同的适用场合。
使用插入排序法，交换排序法，选择排序法设计与实现算法程序完成线性表的排序号。
通过测试分析说明各排序算法的优缺点。
通过实验结果分析，总结直接排序法、希尔排序法、冒泡排序法、选择排序法、快速排序法、堆排序等算法六类算法的特点。
我们需要首先，用数组S来存放系统随机产生的100个数据，并放到R数组中，数据由程序随机产生，用户只需查看结果。
然后，利用全局变量times和changes来分别统计起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法的比较次数和移动次数，然后输出结果，并在每一次统计之后，将times和changes都赋值为0。
最后，在主函数中调用用户自定义函数，输出比较结果。
3概要设计
3．1抽象数据类型定义
排序数据类型定义：
ADTpaixu{
数据对象：
D={aij|aij属于{1，2，3…},i,j>0}
数据关系：
R={|ai-1,ai∈D，i=2,...,n}
基本操作：
Insertsort（）;
初始条件：
数组已经存在。
基本思想：
每一步将一个待排序的序列的记录，按其主关键的大小插入到前面已经排序的文件中适当的位置，知道全部插完为止。
Shellsort（）;
初始条件：
数组已经存在。
基本思想：
先取定一个正整数d1Bubblesort（）;
初始条件：
数组已经存在。
基本思想：
两两比较待排序记录的键值，并交换不满足顺序要求的那些偶对，直到全部满足顺序要求为止。
QuickSort（intlow,inthigh）；
初始条件：
数组已经存在。
基本思想：
在待排序的n个记录中任取一个记录（通常取第一个记录），以该记录的键值为基准用交换的方法将所有记录分成两部分，所有键值比它小的安置在一部分，所有键值比它大的安置在另一部分，并把该记录排在两部分的中间，也就是该记录的最终位置。
这个过程称为一趟快速排序。
然后分别对所划分的两部分重复上述过程，一直重复到每部分内只有一个记录为止排序完成。
Selectsort（）;
初始条件：
数组已经存在。
基本思想：
每次从待排序的记录中选出键值最小（或最大）的记录，顺序放在已排序的记录序列的最后，直到全部排完。
对待排序的文件进行n-1趟扫描，第i趟扫描选出剩下的n-i+1个记录，并与第i个记录交换。
Heap（）;
初始条件：
数组已经存在。
基本思想：
对一组待排序的的键值，首先是把它们按堆的定义排列成一个序列（称为初建堆），这就找到了最小键值，然后把最小的键值取出，用剩下的键值再重建堆，便得到次小键值，如此反复进行，知道把全部键值排好序为止。
}ADT排序
3．2模块划分
本程序包括两个模块：
（1）主程序模块
voidmain（）
{
初始化；
随机数的产生；
调用子函数
}；
（2）子函数模块：
实现直接插入排序的抽象数据类型。
实现希尔排序的抽象数据类型。
实现冒泡排序的抽象数据类型。
实现快速排序的抽象数据类型。
实现选择排序的抽象数据类型。
实现堆排序的抽象数据类型。
最后输出相应算法的比较次数（至少有五种不同的数据）和移动次数（关键字的交换记为三次移动）。
从而直观的判断各内部排序算法性能的优劣性。
4详细设计
4．1数据类型的定义
（1）直接插入排序类型：
voidInsertsort（）;
（2）希尔排序类型：
voidShellsort（）;
（3）冒泡排序类型：
voidBubblesort（）;
（4）快速排序类型：
voidQuickSort（intlow,inthigh）;
（5）选择排序类型：
voidSelectsort（）;
（6）堆排序类型：
voidHeap（）;
4．2主要模块的算法描述
（1）系统的总体结构
内部排序算法性能分析
堆排序
快速排序
选择排序
冒泡排序
希尔排序
直接插入排序
输出各种排序的排序结果和排序的比较次数和移动次数
图4.20总体结构图
（2）运行环境与开发环境
六种排序结构的性能分析的运行环境规定为：
硬件配置：
单机系统。
软件配置：
windows操作系统。
开发平台：
该程序借助C语言编程实现，事例采用VinualC++作为编程开发工具。
（3）下面是主程序的结构图和几个主要模块的流程图和相应的程序代码
开始
循环
产生一组随机数
将随机数保存在数组中
堆排序
选择排序
快速排序
起泡排序
希尔
排序
插入排序
记录关键字的比较次数和移动次数
输出关键字的比较次数和移动次数
结束
4.21主程序结构图
排序是一种重要的数据结构，在我们的现实生活中有许多地方要用到排序，比如：
学生的成绩，当学生人数比较少是我们可以人工的进行排序，但是当学生数量达到一定程度，我们进行人工排序会花费大量的时间。
那这时我们所编写的排序程序就派上大的用场了，我们所编写的程序有六种基本的排序方法，以下就是我们一个整体排序的代码，能体现我们六种排序的一个基本的结构，通过这里我们可以选择相应的序号进行相应的排序，以下就是整体排序的代码：
#include
#include
#include
#include
#defineL100
#defineFALSE0
#defineTRUE1
/*typedefstruct
{
intkey;
charotherinfo;
}RecType;*/
//typedefRecTypeSeqlist[L+1];
ints[100],R[100];
intnum;
inttimes=0,changes=0;
//SeqlistR;
voidInsertsort（）;
voidBubblesort（）;
voidQuickSort（intlow,inthigh）;
voidShellsort（）;
voidSelectsort（）;
voidHeap（）;
intPartition（）;
voidmain（）
{
//SeqlistS;
inti,k;
charch1,ch2,q;
printf（"产生100个随机数：
\n"）;
srand（（unsigned）time（NULL））;
for（i=1;i<=L;i++）
{
s[i]=rand（）%100;
}
for（i=1;i<=L;i++）
{
printf（"%4d",s[i]）;
}
printf（"\n\t排序数据已经输入完毕！
"）;
for（i=1;i<=L;i++）
R[i]=s[i];
ch1='y';
while（ch1=='y'||ch1=='Y'）
{
printf（"\n\n\n\n\n\t\t\t排序性能分析\n"）;
printf（"\t\t***************************************\n"）;
printf（"\t\t*1--------直接插入排序---------*\n"）;
printf（"\t\t*2--------希尔排序---------*\n"）;
printf（"\t\t*3--------冒泡排序---------*\n"）;
printf（"\t\t*4--------快速排序----------*\n"）;
printf（"\t\t*5--------选择排序---------*\n"）;
printf（"\t\t*6--------堆排序----------*\n"）;
printf（"\t\t*0--------返回----------*\n"）;
printf（"\t\t***************************************\n"）;
printf（"\t\t请选择菜单号（0---6）:
"）;
scanf（"%c",&ch2）;getchar（）;
for（i=1;i<=L;i++）
R[i]=s[i];
switch（ch2）
{
case'1':
Insertsort（）;break;
case'2':
Shellsort（）;break;
case'3':
Bubblesort（）;break;
case'4':
printf（"\n\t\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
getchar（）;printf（"\n"）;
num=0;QuickSort（1,L）;
break;
case'5':
Selectsort（）;break;
case'6':
Heap（）;break;
case'0':
ch1='n';break;
default:
printf（"\t\t输入错误！
请重新输入！
\n\t\t"）;
}
if（ch2!
='0'）
{
if（ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8'）
printf（"\n\t排序演示输出完毕！
\n"）;
printf（"\n\t请按回车键返回主菜单..."）;
q=getchar（）;
if（q!
='\xA'）
{
getchar（）;ch1='n';
}
}
}
}
结束
printf（“%5d,”R[k]）;
输入要排序的一组元素
i=2
getchar（）;
Maltiplex
printf（“/n/n”）;
i++
Maltiplex
i<=L
k++
开始
k<=L
k=1
inti,j,k,m=0
N
Y
N
Y
Y
4.22直接排序关键字比较次数和移动次数的流程图
此函数voidInsertsort（）的程序代码如下：
voidInsertsort（）//直接插入排序
{
inti,j,k,m=0;
printf（"\n\t\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
getchar（）;
printf（"\n"）;
for（i=2;i<=L;i++）
{
if（R[i]{
R[0]=R[i];j=i-1;
while（R[0]{
times++;
changes++;
R[j+1]=R[j];j--;
}
R[j+1]=R[0];
changes++;
}
m++;times++;
}
printf（"\n\n"）;
printf（"\t最终排序结果为：
"）;
for（i=1;i<=L;i++）
printf（"%5d",R[i]）;
printf（"\n"）;
printf（"\n\t直接插入排序的比较次数为%d",times）;
printf（"\n\t直接插入排序的移动次数为%d",changes）;
times=0;
changes=0;
}
开始
输入要排序的一组元素
初始化变量i,j,gap=L/2,m=0
m小于gap
i小于元素总个数
j=i+gap
j小于元素总个数
第i个元素大于第j个元素
交换第i个元素第j个元素
gap为原来的一半
输出关键字的比较次数和移动次数
结束
4.23希尔排序关键字比较次数和移动次数
此函数voidShellsort（）的程序代码如下：
voidShellsort（）//希尔排序
{
inti,j,gap,x,m=0,k;
printf（"\n\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
getchar（）;
printf（"\n"）;
gap=L/2;
while（gap>0）
{
for（i=gap+1;i<=L;i++）
{
j=i-gap;
while（j>0）
{
times++;
if（R[j]>R[j+gap]）
{
x=R[j];R[j]=R[j+gap];
R[j+gap]=x;
j=j-gap;
changes++;
}
else
j=0;
}
}
gap=gap/2;
m++;
}
printf（"\n\n"）;
printf（"\t最终排序结果为：
"）;
for（i=1;i<=L;i++）
printf（"%5d",R[i]）;
printf（"\n"）;
printf（"\n\t希尔排序的比较次数为%d",times）;
printf（"\n\t希尔排序的移动次数为%d",changes）;
times=0;
changes=0;
}
开始
输入要排序的一组元素
i=1,j=1
定义临时中间变量k，并赋初值
i<元素总个数
N
ij<元素总个数
NY
j=j+1
第j个元素>第j+1个元素
Y
N
利用k交换第j个元素和第j+1个元素
Y
输出比较次数和移动次数
结束
4.24冒泡排序关键字比较次数和移动次数的流程图
此函数voidBubblesort（）的程序代码如下：
voidBubblesort（）//冒泡排序
{
inti,j,k;
intexchange;
printf（"\n\t\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
getchar（）;
printf（"\n"）;
for（i=1;i<=L;i++）
{
exchange=FALSE;
for（j=L;j>=i+1;j--）
{
times++;
if（R[j]{
R[0]=R[j];
R[j]=R[j-1];
R[j-1]=R[0];
exchange=TRUE;
changes+=3;
}}
if（exchange）;
}
printf（"\n\n"）;
printf（"\t最终排序结果为：
"）;
for（i=1;i<=L;i++）
printf（"%5d",R[i]）;
printf（"\n"）;
printf（"\n\t冒泡排序的比较次数为%d",times）;
printf（"\n\t冒泡排序的移动次数为%d",changes）;
times=0;
changes=0;
}
开始
输入要排序的一组元素
初始化变量priot，low，high
Low小于high
Y
High减1
Low++
第low个元素与第high个元素交换
第high个元素大于priot
第high个元素与第low个元素交换
第low个元素小于priot
结束
输出关键字的比较次数和移动次数
Y
Y
4.25快速排序关键字比较次数和移动次数的流程图
此函数intPartition（inti,intj）的程序代码如下：
intPartition（inti,intj）//快速排序
{
intpirot=R[i];
while（i{
while（i=pirot）
{j--;
times++;
}
if（i{R[i++]=R[j];
changes++;
}
while（i{i++;
times++;
}
if（i{R[j--]=R[i];
changes++;
}
}
R[i]=pirot;
returni;
}
voidQuickSort（intlow,inthigh）
{
intpirotpos,k,i;
if（low{
pirotpos=Partition（low,high）;
num++;
QuickSort（low,pirotpos-1）;
QuickSort（pirotpos+1,high）;
}
printf（"\n\n"）;
printf（"\t最终排序结果为：
\n"）;
for（i=1;i<=L;i++）
printf（"%5d",R[i]）;
printf（"\n"）;
printf（"\n\t快速排序的比较次数为%d",times）;
printf（"\n\t快速排序的移动次数为%d",changes）;
times=0;
changes=0;
}
开始
输入要排序的一组元素
i=1，j=1
定义临时中间变量h，并赋初值
i<元数总个数
N
做第i趟排序
Y
i=i+1
在无序区R[i-n]中选h最小记录R[h]
h记下目前找到的最小关键字所在的位置
交换R[i]和R[h]
输出比较次数和移动次数
结束
4.26选择排序关键字比较次数和移动次数的流程图
此函数voidSelectsort（）的程序代码如下：
voidSelectsort（）//选择排序
{
inti,j,k,h;
printf（"\n\t\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
getchar（）;
printf（"\n"）;
for（i=1;i<=L;i++）
{
h=i;
for（j=i+1;j<=L;j++）
{times++;
if（R[j]h=j;
if（h!
=j）
{
R[0]=R[h];R[h]=R[i];R[i]=R[0];
changes+=3;
}
}
}
printf（"\n\n"）;
printf（"\t最终排序结果为：
"）;
for（i=1;i<=L;i++）
printf（"%5d",R[i]）;
printf（"\n"）;
printf（"\n\t选择排序的比较次数为%d",times）;
printf（"\n\t选择排序的比较次数为%d",changes）;
times=0;
changes=0;
}
开始
输入要排序的一组元素
定义临时中间变量k，并赋初值
将二叉树转换成堆
i=总元素个数-1
i<=1
N
将堆的根植和最后一个值交换
Y
i--,k++
输出比较次数和移动次数
结束
4.27堆排序关键字比较次数和移动次数的流程图
此函数voidCreateHeap（introot,intindex）的程序代码如下：
voidCreateHeap（introot,intindex）//建堆
{
intj,temp,finish;
j=2*root;
temp=R[root];
finish=0;
while（j<=index&&finish==0）
{
if（jif（R[j]{
j++;
times++;
}
if（temp>=R[j]）
{
finish=1;//堆建立完成
times++;
}
else
{
R[j/2]=R[j];//父结点=当前结点
j=j*2;
changes++;
}
}
R[j/2]=temp;//父结点=root值
}
voidHeapSort（）
{
inti,j,temp,k;
for（i=（L/2）;i>=1;i--）//将二叉树转换成堆
CreateHeap（i,L）;//建堆
for（i=L-1,k=1;i>=1;i--,k++）
{
temp=R[i+1];//堆（heap）的root值和最后一个值交换
R[i+1]=R[1];
R[1]=temp;
changes+=3;
CreateHeap（1,i）;
}
}
voidHeap（）
{intk;
printf（"\n\t尚未排序的数据为（回车继续）：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
printf（"\n\t"）;
getchar（）;
HeapSort（）;
printf（"\n\n"）;
printf（"\t最终排序结果为：
"）;
for（k=1;k<=L;k++）
printf（"%5d",R[k]）;
printf（"\n"）;
printf（"\n\t堆排序的比较次数为%d",times）;
printf（"\n\t堆排序的移动次数为%d",changes）;
times=0;
changes=0;
}
5测试分析
以下是进行了99趟排序后，得到了最终的排序结果，并且也知道了直接插入排序的比较次数和移动次数
下面是希尔排序
升级会员 