数据结构实验报告排序.docx
《数据结构实验报告排序.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告排序.docx（23页珍藏版）》请在冰豆网上搜索。
数据结构实验报告排序
（此文档为word格式，下载后您可任意编辑修改！
）
2008级数据结构实验报告
实验名称：
实验四排序
学生姓名：
班级：
班内序号：
学号：
日期：
2009年12月6日
1．实验要求
a.实验目的
通过实现下述实验内容，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
b.实验内容
使用简单数组实现下面各种排序算法，并进行比较。
排序算法：
1、插入排序
2、希尔排序
3、冒泡排序
4、快速排序
5、简单选择排序
6、堆排序（选作）
7、归并排序（选作）
8、基数排序（选作）
9、其他
2.程序分析
2.1存储结构
存储结构:
顺序存储结构
示意图如下:
2.2关键算法分析
核心算法思想：
1.利用教材讲述的基本算法思想，实现七种排序算法，统计其运行相关数据。
2.将七种排序函数入口地址作为函数指针数组，实现快速调用和统计。
使得程序代码可读性增、结构更加优化。
关键算法思想描述和实现：
关键算法1：
实现七种算法的基本排序功能。
1、插入排序：
依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。
2、希尔排序：
先将整个序列分割成若干个子列，分别在各个子列中运用直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
3、冒泡排序：
两两比较相邻记录的关键码，如果反序则交换，直到没有反序记录为止。
4、快速排序：
首先选择一个基准，将记录分割为两部分，左支小于或等于基准，右支则大于基准，然后对两部分重复上述过程，直至整个序列排序完成。
5、选择排序：
从待排序的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第一个记录交换位置；然后从不包括第一个位置上的记录序列中选择关键码最小（或最大）的记录并将它与序列中的第二个记录交换位置；如此重复，直到序列中只剩下一个记录为止。
6、堆排序：
通过建立大根堆或者小根堆，取出根节点，反复调整堆使之保持大根堆或者小根堆，直至最后序列有序。
7、归并排序：
将若干个有序序列两两归并，直至所有待排序的记录都在一个有序序列为止。
C++实现：
参看源代码的七个排序函数。
关键算法2：
获取当前系统时间，精确到微秒，分别在代码运行前后调用记录前后时间，再相减即可得到代码运行时间。
此处调用函数QueryPerformanceCounter（）用于得到高精度计时器的值。
C++实现：
longdoubleSort:
:
GetNowTime（void）
{
LARGE_INTEGERlitmp;
LONG64QPart;
QueryPerformanceCounter（&litmp）;
QPart=litmp.QuadPart;
return（longdouble）QPart;
}
关键算法3：
试图寻求最简短的代码以实现多达七种排序算法的简单调用、乱序和顺序以及逆序数据的分别排序和性能指标统计、算法时间的精确而简易的统计、算法移动次数和比较次数的精确统计。
如果设计不合理，将使得主调函数的调用代码冗长，可读性变差。
采用以下三种方法实现：
1使用函数指针数组，分别指向各排序函数的入口地址，然后在Statistics（）函数中加以调用，使得排序函数运行在统计时间函数之间，这样使用一个for语句即可实现七种算法的一次性调用、时间统计、移动次数和比较次数统计。
C++实现：
voidStatistics（Sort&obj,inti,intj）
{
obj.startTime=obj.GetNowTime（）;
（obj.*pFunction[i]）（obj.pRandom1）;
obj.endTime=obj.GetNowTime（）;
obj.runtime[i][j]=obj.endTime-obj.startTime;
}
2使用两个数组实现乱序、顺序以及逆序数据的排序，大大节省了空间的消耗。
基本思想为：
随机序列产生一个指定长度的乱序序列，然后通过memcpy（）函数拷贝到第二个数组里，第二个数组作为乱序序列的保存数组，每次对第一个数组进行排序，之后拷贝第二个数组中的乱序序列到第一个数组，实现各次乱序排列。
只要算法正确（第一步可以检验），之后顺序排列只需反复对第一个数组进行操作即可，再后用第二个数组保存逆序数组，然后同样在每次排序之后复制第二数组存储的乱序序列到第一组，对第一组反复排序即可。
C++实现：
请参看源代码。
3建立两个数组分别统计运行次数，再统一使用一个数组记录七种算法在三种不同数据情况下的移动次数和交换次数。
在分别运行乱序、顺序和逆序数组排序时取出前两个数组的值写入第三个数组，然后置零继续统计。
C++实现：
请参看源代码。
时间复杂度与空间复杂度：
理论分析可以得出各种排序算法的时间复杂度和空间复杂度，如下表所示：
排序方法
平均情况
最好情况
最坏情况
辅助空间
直接插入排序
O（n2）
O（n）
O（n2）
O
（1）
希尔排序
O（nlog2n）~O（n2）
O（n1.3）
O（n2）
O
（1）
起泡排序
O（n2）
O（n）
O（n2）
O
（1）
快速排序
O（nlog2n）
O（nlog2n）
O（n2）
O（log2n）~O（n）
简单选择排序
O（n2）
O（n2）
O（n2）
O
（1）
堆排序
O（nlog2n）
O（nlog2n）
O（nlog2n）
O
（1）
归并排序
O（nlog2n）
O（nlog2n）
O（nlog2n）
O（n）
3.程序运行结果
程序运行框图：
实际测试和分析：
实际运行结果如下：
（其中随机产生的数据量为1000）
图一加入了次数统计的运行结果
图二没有加入次数统计的运行结果
作如下分析：
1、多次运行之后统计，从乱序的时间消耗来看，基本符合理论分析。
参看图一。
2、由于加入了统计次数的代码，势必增加时间开销，这样统计出来的时间将有一定的误差。
假若比较次数和移动次数相差较多，则将产生较大的实验误差。
故重新写了代码，没有加入比较次数和移动次数的比较的代码，运行结果如图二所示，均采用随机产生的1000个乱序数据进行排序。
可以看出时间有所减少。
因而图二更加接近实际。
3、本程序中的代码有的采用了递归的形式，如果考虑用栈来模拟的话，效率会有提升，所以运行时间还和代码的实现有关，代码本身只是描述了算法思想，并没有再进行编写方面的优化，因而还不能完全反映出每个算法的根本性能。
4.总结
1、在初期构思代码的时候，首先构造了各种算法的基本实现代码，封装成类，已经能够实现七种排序的基本功能，并且测试无误。
后来考虑能否优化本程序，首先考虑到测试算法的需求，需要大量随机数，因为增添了随机函数发生器，满足各种测试条件的需求。
之后考虑如何能简化代码以实现多达七种排序算法的简单调用、乱序和顺序以及逆序数据的分别排序和性能指标统计、算法时间的精确而简易的统计、算法移动次数和比较次数的精确统计。
如果设计不合理，将使得主调函数的调用代码冗长，可读性变差。
因而采用了函数指针数组和统一的接口函数，采用二维数组存储移动次数和比较次数，调用精确的系统函数实现时间的统计。
此外还添加了一些列优化，特别是函数封装的方法，使得程序的结构变得更加合理，版面风格也变得好看，可读性增强。
2、程序的优化是一个艰辛的过程，如果只是实现一般的功能，将变得容易很多，当加上优化，不论是效率还是结构优化，都需要精心设计。
这次做优化的过程中，遇到不少阻力。
由于优化中用到很多类的封装和访问控制方面的知识，而这部分知识恰好是大一一年学习的薄弱点。
因而以后要多花力气学习C++编程语言，必须要加强这方面的训练，这样才能在将编程思想和数据结构转换为代码的时候能得心应手。
3、改进：
本程序代码设计时运用了递归的调用方式，效率还可以通过将其转换为栈模拟的方式得以提高。
在实现类的封装的时候为了共享数据采用了友元函数的方式，考虑能否使用其他方式使得类的封装更加完善。
附录源码：
（包括三个cpp文件）
Main.cpp
#include
usingnamespacestd;
#include"Sort.[7]）（longint[]）={&Sort:
:
InsertSort,&Sort:
:
ShellSort,&Sort:
:
BubbleSort,&Sort:
:
QuickSort,&Sort:
:
SelectSort,&Sort:
:
HeapSort,&Sort:
:
MergeSort};
char*funcName[7]={"1、插入排序:
","2、希尔排序:
","3、冒泡排序:
","4、快速排序:
","5、选择排序:
","6、堆排序:
","7、归并排序:
"};
*****************************统计时间函数*****************************
voidStatistics（Sort&obj,inti,intj）
{
obj.startTime=obj.GetNowTime（）;
（obj.*pFunction[i]）（obj.pRandom1）;
obj.endTime=obj.GetNowTime（）;
obj.runtime[i][j]=obj.endTime-obj.startTime;
}
****************************主调函数*********************************
intmain（void）
{
cout<<"程序说明：
\n1、默认产生10个随机数，如需加大数据量，请修改常量Max;\n2、默认打印排序的结果以显示算法正确与否，如果想不打印，请注释相关语句。
\n\n";
Sortobj;
obj.CreateData（）;
memcpy（obj.pRandom1,obj.pRandom2,（Max+1）*sizeof（longint））;
inti（0）,j（0）;
*************************乱序序列*********************************
obj.SetTimesZero（）;
for（i=0;i<7;i++）
{
Statistics（obj,i,0）;
cout<obj.PrintArray（obj.pRandom1）;
if（i!
=6）
memcpy（obj.pRandom1,obj.pRandom2,（Max+1）*sizeof（longint））;
}
obj.RecordTimes（0）;
*************************顺序序列*********************************
obj.SetTimesZero（）;
for（i=0;i<7;i++）
Statistics（obj,i,1）;
obj.RecordTimes
（2）;
*************************逆序序列*********************************
obj.SetTimesZero（）;
for（i=1;i<=Max;i++）
obj.pRandom2[i]=obj.pRandom1[Max+1-i];
memcpy（obj.pRandom1,obj.pRandom2,（Max+1）*sizeof（longint））;
for（i=0;i<7;i++）
{
Statistics（obj,i,2）;
memcpy（obj.pRandom1,obj.pRandom2,（Max+1）*sizeof（longint））;
}
obj.RecordTimes（4）;
************************统计排序数据******************************
obj.PrintStatistics（funcName）;
return0;
}
Sort.cpp
constintMax=10;
classSort
{
public:
Sort（）;
~Sort（）;
voidCreateData（void）;
intInsertSort（longint[]）;
intShellSort（longint[]）;
intBubbleSort（longint[]）;
intQuickSort（longint[]）;
intQuickSortRecursion（longint[],int,int）;
intQuickSortPatition（longint[],int,int）;
intSelectSort（longint[]）;
intHeapSort（longint[]）;
voidHeapSortSift（longint[],int,int）;
intMergeSort（longint[]）;
voidMerge（longint[],longint[],int,int,int）;
voidMergePass（longint[],longint[],int）;
longdoubleGetNowTime（void）;
voidPrintArray（longint*）;
voidSetTimesZero（void）;
voidRecordTimes（int）;
friendvoidStatistics（Sort&,int,int）;
voidPrintStatistics（char*[]）;
friendintmain（void）;
private:
longint*pRandom1;
longint*pRandom2;
longdoubleruntime[7][3];
intcomparetimes[7];
intmovetimes[7];
inttimestable[7][6];
longdoublestartTime,endTime;
};
Function.cpp
#include"Sort.";如果不输出原始数组，请注释掉此两行
PrintArray（pRandom2）;
}
********************************************************简单插入排序*******************************************************************
intSort:
:
InsertSort（longintparray[]）
{
intj=0;
for（inti=2;i<=Max;i++）
{
parray[0]=parray[i];
comparetimes[0]++;
for（j=i-1;parray[0]{
parray[j+1]=parray[j];
movetimes[0]++;
}
parray[j+1]=parray[0];
movetimes[0]+=2;
}
return0;
}
**********************************************************希尔排序***********************************************************************
intSort:
:
ShellSort（longintparray[]）
{
intj=0;
for（intd=Max2;d>=1;d=2）
{
for（inti=d+1;i<=Max;i++）
{
parray[0]=parray[i];
comparetimes[1]++;
for（j=i-d;j>0&&parray[0]{
parray[j+d]=parray[j];
movetimes[1]++;
}
parray[j+d]=parray[0];
movetimes[1]+=2;
}
}
return0;
}
**********************************************************冒泡排序***********************************************************************
intSort:
:
BubbleSort（longintparray[]）
{
intexchange=Max;
intbound,j;
while（exchange）
{
bound=exchange;
exchange=0;
for（j=1;j{
comparetimes[2]++;
if（parray[j]>parray[j+1]）
{
parray[0]=parray[j];
parray[j]=parray[j+1];
parray[j+1]=parray[0];
exchange=j;
movetimes[2]+=3;
}
}
}
return0;
}
***********************************************************快速排序**********************************************************************
intSort:
:
QuickSort（longintparray[]）
{
QuickSortRecursion（parray,1,Max）;
return0;
}
intSort:
:
QuickSortRecursion（longintparray[],intfirst=1,intend=Max）
{
if（first{
intpivot=QuickSortPatition（parray,first,end）;
QuickSortRecursion（parray,first,pivot-1）;左侧子序列排序
QuickSortRecursion（parray,pivot+1,end）;右侧子序列排序
}
return0;
}
intSort:
:
QuickSortPatition（longintr[],intfirst,intend）
{
inti=first;
intj=end;
inttemp;
while（i{
while（i{
j--;
comparetimes[3]++;
}右侧扫描
if（i{
temp=r[i];将较小记录交换到前面
r[i]=r[j];
r[j]=temp;
i++;
movetimes[3]+=3;
}
while（i{
i++;
comparetimes[3]++;
}左侧扫描
if（i{
temp=r[j];
r[j]=r[i];
r[i]=temp;将较大记录交换到后面
j--;
movetimes[3]+=3;
}
}
returni;i为轴值记录的最终位置
}
***********************************************************选择排序**********************************************************************
intSort:
:
SelectSort（longintparray[]）
{
inti,j,index,temp;
for（i=1;i{
index=i;
for（j=i+1;j<=Max;j++）
{
comparetimes[4]++;在无序区中选取最小记录
if（parray[j]index=j;
}
if（index!
=i）
{
temp=parray[i];
parray[i]=parray[index];
parray[index]=temp;
movetimes[4]+=3;
}
}
return0;
}
*************************************************************堆排序***********************************************************************
intSort:
:
HeapSort（longintparray[]）
{
inti;
for（i=Max2;i>=1;i--）
HeapSortSift（parray,i,Max）;
for（i=1;i{
parray[0]=parray[Max-i+1];
parray[Max-i+1]=parray[1];
parray[1]=parray[0];
movetimes[5]+=3;
HeapSortSift（parray,1,Max-i）;
}
return0;
}
voidSort:
:
HeapSortSift（longintparray[],intk,intm）
{
inti,j;
i=k;
j=2*i;置i为要筛的结点，j为i的左孩子
while（j<=m）筛选还没有进行到叶子
{
if（j{
j++;
comparetimes[5]++;
}比较i的左右孩子，j为较大者
if（parray[i]>parray[j]
升级会员 