数据结构实验报告——排序

(此文档为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++实现：

long double Sort::GetNowTime(void)

{

LARGE_INTEGER litmp;

LONG64 QPart;

QueryPerformanceCounter(&litmp);

QPart=litmp.QuadPart;

return (long double)QPart;

}

关键算法3：

试图寻求最简短的代码以实现多达七种排序算法的简单调用、乱序和顺序以及逆序数据的分别排序和性能指标统计、算法时间的精确而简易的统计、算法移动次数和比较次数的精确统计。如果设计不合理，将使得主调函数的调用代码冗长，可读性变差。

采用以下三种方法实现：

①使用函数指针数组，分别指向各排序函数的入口地址，然后在Statistics()函数中加

以调用，使得排序函数运行在统计时间函数之间，这样使用一个for语句即可实现

七种算法的一次性调用、时间统计、移动次数和比较次数统计。

C++实现：

void Statistics(Sort &obj,int i,int j)

{

obj.startTime=obj.GetNowTime();

(obj.*pFunction[i])(obj.pRandom1);

obj.endTime=obj.GetNowTime();

obj.runtime[i][j]=obj.endTime-obj.startTime;

}

②使用两个数组实现乱序、顺序以及逆序数据的排序，大大节省了空间的消耗。基本

思想为：随机序列产生一个指定长度的乱序序列，然后通过memcpy()函数拷贝到

第二个数组里，第二个数组作为乱序序列的保存数组，每次对第一个数组进行排序，之后拷贝第二个数组中的乱序序列到第一个数组，实现各次乱序排列。只要算法正

确（第一步可以检验），之后顺序排列只需反复对第一个数组进行操作即可，再后

用第二个数组保存逆序数组，然后同样在每次排序之后复制第二数组存储的乱序序

列到第一组，对第一组反复排序即可。

C++实现：

请参看源代码。

③建立两个数组分别统计运行次数，再统一使用一个数组记录七种算法在三种不同数

据情况下的移动次数和交换次数。在分别运行乱序、顺序和逆序数组排序时取出前两个数组的值写入第三个数组，然后置零继续统计。

C++实现：

请参看源代码。

时间复杂度与空间复杂度：

理论分析可以得出各种排序算法的时间复杂度和空间复杂度，如下表所示：排序方法平均情况最好情况最坏情况辅助空间直接插入排序O(n2)O(n)O(n2)O(1)希尔排序O(n log

n)~O(n2)O(n1.3)O(n2)O(1)

2

起泡排序O(n2)O (n) O(n2)O(1)

快速排序O(n log2n)O(n log2n)O(n2)O(log

n) ~O(n)

2简单选择排序O(n2)O(n2)O(n2)O(1)堆排序O(n log2n)O(n log2n)O (n log2n) O(1)

归并排序O(n log2n)O(n log2n)O(n log2n)O(n)

3. 程序运行结果程序运行框图：

实际测试和分析：

实际运行结果如下：（其中随机产生的数据量为1000）

图一加入了次数统计的运行结果

图二没有加入次数统计的运行结果

作如下分析：

1、多次运行之后统计，从乱序的时间消耗来看，基本符合理论分析。参看图一。

2、由于加入了统计次数的代码，势必增加时间开销，这样统计出来的时间将有一定的误差。

假若比较次数和移动次数相差较多，则将产生较大的实验误差。故重新写了代码，没有加入比较次数和移动次数的比较的代码，运行结果如图二所示，均采用随机产生的1000个乱序数据进行排序。可以看出时间有所减少。因而图二更加接近实际。

3、本程序中的代码有的采用了递归的形式，如果考虑用栈来模拟的话，效率会有提升，所以运行时间还和代码的实现有关，代码本身只是描述了算法思想，并没有再进行编写方面的优化，因而还不能完全反映出每个算法的根本性能。

4. 总结

1、在初期构思代码的时候，首先构造了各种算法的基本实现代码，封装成类，已经能够实现七种排序的基本功能，并且测试无误。后来考虑能否优化本程序，首先考虑到测试算法的需求，需要大量随机数，因为增添了随机函数发生器，满足各种测试条件的需求。之后考虑如何能简化代码以实现多达七种排序算法的简单调用、乱序和顺序以及逆序数据的分别排序和性能指标统计、算法时间的精确而简易的统计、算法移动次数和比较次数的精确统计。如果设计不合理，将使得主调函数的调用代码冗长，可读性变差。因而采用了函数指针数组和统一的接口函数，采用二维数组存储移动次数和比较次数，调用精确的系统函数实现时间的统计。此外还添加了一些列优化，特别是函数封装的方法，使得程序的结构变得更加合理，版面风格也变得好看，可读性增强。

2、程序的优化是一个艰辛的过程，如果只是实现一般的功能，将变得容易很多，当加上优化，不论是效率还是结构优化，都需要精心设计。这次做优化的过程中，遇到不少阻力。由于优化中用到很多类的封装和访问控制方面的知识，而这部分知识恰好是大一一年学习的薄弱点。因而以后要多花力气学习C++编程语言，必须要加强这方面的训练，这样才能在将编程思想和数据结构转换为代码的时候能得心应手。

3、改进：本程序代码设计时运用了递归的调用方式，效率还可以通过将其转换为栈模拟的方式得以提高。在实现类的封装的时候为了共享数据采用了友元函数的方式，考虑能否使用其他方式使得类的封装更加完善。

（包括三个cpp文件）

Main.cpp

#include

using namespace std;

#include"Sort.[7])(long int

[])={&Sort::InsertSort,&Sort::ShellSort,&Sort::BubbleSort,&Sort::QuickSort,&Sort::Selec tSort,&Sort::HeapSort,&Sort::MergeSort};

char *funcName[7]={"1、插入排序:","2、希尔排序:","3、冒泡排序:","4、快速排序:","5、选择排序:","6、堆排序:","7、归并排序:"};

*****************************统计时间函数*****************************

void Statistics(Sort &obj,int i,int j)

{

obj.startTime=obj.GetNowTime();

(obj.*pFunction[i])(obj.pRandom1);

obj.endTime=obj.GetNowTime();

obj.runtime[i][j]=obj.endTime-obj.startTime;

}

****************************主调函数*********************************

int main(void)

{

cout<<"程序说明：\n1、默认产生10个随机数，如需加大数据量，请修改常量Max;\n2、默认打印排序的结果以显示算法正确与否，如果想不打印，请注释相关语句。\n\n";

obj.CreateData();

memcpy(obj.pRandom1,obj.pRandom2,(Max+1)*sizeof(long int));

int i(0),j(0);

*************************乱序序列*********************************

obj.SetTimesZero();

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

{

Statistics(obj,i,0);

cout<

if(i!=6)

memcpy(obj.pRandom1,obj.pRandom2,(Max+1)*sizeof(long int));

}

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(long int));

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

{

Statistics(obj,i,2);

memcpy(obj.pRandom1,obj.pRandom2,(Max+1)*sizeof(long int));

}

obj.RecordTimes(4);

************************统计排序数据****************************** obj.PrintStatistics(funcName);

return 0;

}

Sort.cpp

const int Max =10;

class Sort

{

public:

Sort();

~Sort();

void CreateData(void);

int InsertSort(long int []);

int ShellSort(long int []);

int BubbleSort(long int []);

int QuickSort(long int []);

int QuickSortRecursion(long int [], int ,int);

int QuickSortPatition(long int [], int , int );

int SelectSort(long int []);

int HeapSort(long int []);

void HeapSortSift(long int [], int , int );

int MergeSort(long int []);

void Merge(long int [],long int [], int , int , int );

void MergePass(long int [],long int [] , int );

long double GetNowTime(void);

void PrintArray(long int*);

void SetTimesZero(void);

void RecordTimes(int);

friend void Statistics(Sort &,int ,int);

void PrintStatistics(char *[]);

friend int main(void);

private:

long int *pRandom1;

long int *pRandom2;

long double runtime[7][3];

int comparetimes[7];

int movetimes[7];

int timestable[7][6];

long double startTime,endTime;

};

Function.cpp

#include"Sort."; 如果不输出原始数组，请注释掉此两行PrintArray(pRandom2);

}

********************************************************简单插入排序******************************************************************* int Sort::InsertSort(long int parray[])

{

int j=0;

for(int i =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;

}

return 0;

}

**********************************************************希尔排序

*********************************************************************** int Sort::ShellSort(long int parray[])

{

int j=0;

for(int d=Max2;d>=1;d=2)

{

for(int i=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;

}

}

return 0;

}

**********************************************************冒泡排序

*********************************************************************** int Sort::BubbleSort(long int parray[])

{

int exchange=Max;

int bound,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;

}

}

}

return 0;

}

***********************************************************快速排序

********************************************************************** int Sort::QuickSort(long int parray[])

{

QuickSortRecursion(parray,1, Max);

return 0;

}

int Sort::QuickSortRecursion(long int parray[], int first=1, int end=Max)

{

if (first

{

int pivot=QuickSortPatition(parray, first, end);

QuickSortRecursion(parray, first, pivot-1);左侧子序列排序

QuickSortRecursion(parray, pivot+1, end); 右侧子序列排序}

return 0;

}

int Sort::QuickSortPatition(long int r[], int first, int end )

{

int i=first;

int j=end;

int temp;

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;

}

}

return i; i为轴值记录的最终位置

}

***********************************************************选择排序

********************************************************************** int Sort::SelectSort(long int parray[])

{

int i,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;

}

}

return 0;

}

*************************************************************堆排序

*********************************************************************** int Sort::HeapSort(long int parray[])

{

int i;

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);

}

return 0;

}

void Sort::HeapSortSift(long int parray[], int k, int m)

{

int i,j;

i=k;

j=2*i; 置i为要筛的结点，j为i的左孩子while (j<=m) 筛选还没有进行到叶子

{

if (j

{

j++;

comparetimes[5]++;

} 比较i的左右孩子，j为较大者if (parray[i]>parray[j])