数据结构课程设计报告 各种排序算法性能比较文档格式.docx

数据结构课程设计报告 各种排序算法性能比较文档格式.docx

《数据结构课程设计报告 各种排序算法性能比较文档格式.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计报告 各种排序算法性能比较文档格式.docx（16页珍藏版）》请在冰豆网上搜索。

直接选择排序;

起泡排序；

Shell排序；

快速排序；

堆排序这些排序方法进行排序,输出关键字的比较次数和移动次数.

四、各种排序的基本原理及时间复杂度分析

1、直接插入排序（InsertSort）

1。

1、基本原理：

假设待排序的n个记录｛R0,R1,…，Rn}顺序存放在数组中，直接插入法在插入记录Ri（i=1,2，…，n-1）时,记录被划分为两个区间［R0,Ri-1]和[Ri+1，Rn-1］,其中,前一个子区间已经排好序，后一个子区间是当前未排序的部分，将关键码Ki与Ki—1Ki-2，…,K0依次比较，找出应该插入的位置,将记录Ri插,然后将剩下的i-1个元素按关键词大小依次插入该有序序列，没插入一个元素后依然保持该序列有序，经过i-1趟排序后即成为有序序列.每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置,直到全部记录插入完成为止。

1.2、时间复杂度分析：

直接插入排序算法必须进行n—1趟。

最好情况下，即初始序列有序，执行n-1趟，但每一趟只比较一次,移动元素两次,总的比较次数是（n-1），移动元素次数是2（n—1）.因此最好情况下的时间复杂度就是O（n）。

最坏情况（非递增）下，最多比较i次，因此需要的比较次数是：

所以，时间复杂度为O（n2）。

2、直接选择排序（SelectSort）

2.1、基本原理:

待排序的一组数据元素中，选出最小的一个数据元素与第一个位置的数据元素交换；

然后在剩下的数据元素当中再找最小的与第二个位置的数据元素交换，循环到只剩下最后一个数据元素为止，依次类推直到所有记录。

第一趟第n个记录中找出关键码最小的记录与第n个记录交换；

第二趟，从第二个记录开始的，2—1个记录中再选出关键码最小的记录与第二个记录交换;

如此,第i趟，则从第i个记录开始的n-i+l个记录中选出关键码最小的记录与第i个记录交换，直到所有记录排好序。

2.2、时间复杂度分析：

该算法运行时间与元素的初始排列无关.不论初始排列如何，该算法都必须执行n-1趟,每趟执行n—i-1次关键字的比较，这样总的比较次数为：

所以，简单选择排序的最好、最坏和平均情况的时间复杂度都为O（n2）。

3、冒泡排序（BubbleSort）

3。

1、基本原理

在每一趟冒泡排序中,依次比较相邻的两个关键字大小，若为反序咋交换。

经过一趟起泡后,关键词大的必须移到最后.按照这种方式进行第一趟在序列（I[0]~I[n-1］）中从前往后进行两个相邻元素的比较,若后者小,则交换，比较n-1次；

第一趟排序结束,最大元素被交换到I[n—1］中,下一趟只需在子序列（I［0]~I[n-2］）中进行；

如果在某一趟排序中未交换元素，则不再进行下一趟排序。

将被排序的记录数组J［1…n]垂直排列，每个记录J[i]看作是重量为J［i]。

key的气泡。

根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：

凡扫描到违反本原则的轻气泡，就使其向上”飘浮"

。

如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止，最后可完成。

3.2、时间复杂度分析

当原始数据正向有序时,冒泡排序出现最好情况。

此时，只需进行一趟排序，作n—1次关键字比较，因此最好情况下的时间复杂度是O（n）。

当原始数据反向有序时，冒泡排序出现最坏情况。

此时，需进行n-1趟排序，第i趟作（n—i）次关键字间的比较，并且需执行（n—i）次元素交换，所以，比较次数为：

因此，最坏情况下的时间复杂度为O（n2）

4、Shell排序（ShellSort）

4。

Shell排序又称缩小增量排序，Shell排序法是以创建者DonaldShell的名字命名的.Shell排序法是对相邻指定距离（称为间隔）的元素进行比较，已知到使用当前间隔进行比较的元素都按顺序排序为止.Shell把间隔缩小一半,然后继续处理,当间隔最终变为1,并且不再出现变化时，Shell排序也就完成了其处理过程.先取一个整数d1〈n，把全部记录分成d1个组，所有距离为d1倍数的记录放在一组中，先在各组内排序；

然后去d2<

d1重复上诉分组和排序工作;

直至所取的增量dt=1（dt<

dt-l〈…<

d2〈d1），即所有记录放在同一组中进行直接插入,直到dt=1，即所有记录放在一组中为止。

4.2、时间复杂度分析

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候,步长最大，所以插入排序的元素个数很少，速度很快;

当元素基本有序了，步长很小,插入排序对于有序的序列效率很高。

所以,希尔排序的时间复杂度会比o（n2）好一些。

由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序,但在不同的插入排序过程中,相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的.所以希尔排序是不稳定的，其时间复杂度为o（n2）。

5、快速排序（QuickSort）

5.1基本原理

首先我们选择一个中间值middle（程序中我们可使用数组中间值），把比中问值小的放在其左边，比中问值大的放在其右边。

由于这个排序算法较复杂，我们先给出其进行一次排序的程序框架。

在待排序的个记录中任意取一个记录（通常取第一个记录）为区分标准，把所有小于该排序的记录移到左边，把所有大于该排序码的记录移到右边,中级放所选记录,为一趟快速排序。

然后对前后两个子序列分别重新上述过程，直到所有记录都排好序.对任意给定的序列中某个元素，经过一趟排序后，将原序列分割成两个子序列（Rp（0），Rp

（1），…,Rp（s—1））和（Rp（s+1）,Rp（s+2）,…，Rp（n—1））,其中前一个子序列中的所有元素的关键词均小于或等于该元素的关键词值Kp（s），后一个子序列中元素的关键词均大于或等于Kp（s）。

称该元素Rp（s）为分割元素，子序列（Rp（0），Rp

（1）,…，Rp（s-1））为其低端序列，（Rp（0）,Rp

（1）,…,Rp（s—1））为其高端序列。

很明显，以后只需对低端和高端序列分别进行快速排序，直到子序列为空或只有一个元素时结束，最后得到有序序列。

总之，每趟使表的第一个元素放在适当位置,将表两分,再对子表进行同样的递归划分，直至划分的子表长度为1。

5。

2、时间复杂度分析

如果每一次分划操作后，左、右两个子序列的长度基本相等，则快速排序的效率最高，其最好情况时间复杂度为O（nlog2n）；

反之，如果每次分划操作所产生的两个子序列，其中之一为空序列,此时,快速排序效率最低,其最坏情况时间复杂度为O（n2）。

如果选择左边第一个元素为主元，则快速排序的最坏情况发生在原始序列正向有序或反向有序时。

快速排序的平均情况时间复杂度为O（nlog2n）。

6、堆排序（Heapsort）

6。

堆排序思想很简单，就是每次把关键词调整为堆，取出堆顶元素与堆中最后一个元素交换，同时令堆的大小减一,把剩余的一些元素重新调整为堆，重复此过程,知道堆中只剩下一个元素,n个关键字序列K1，K2，K3，………称为堆，当且仅当该序列满足如下性质（简称为堆性质）：

（1）Ki<

=K2i且Ki<

=K2i+1或

（2）Ki〈=K2i且Ki>

=K2i+1..若将此序列所存储的向量R[1…n]看作是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：

树中非叶子结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。

根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者的堆称为小根堆。

根结点（亦称为堆顶）的关键字是堆里所有结点关键字中的最大者，称为大根堆。

注意：

堆中任一子树亦是堆。

以上讨论的实际上是二叉堆,类似的可以定义K叉堆

6.2时间复杂度分析

堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。

堆排序的最坏时间复杂度为O（nlogn）。

堆排序的平均性能较接近于最坏性能。

由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件.堆排序是不稳定的,算法时间复杂度O（nlogn）。

五、程序流程图

图5。

1程序流程图

六、程序源代码

＃include〈stdio。

h〉

#include<

stdlib.h>

typedefstruct

｛

intkey；

/＊关键字*/

}RecordNode；

/*排序节点的类型*/

RecordNode*record；

intn;

/*排序对象的大小＊/

｝SortObject；

/＊排序节点的类型＊/

voidInsertSort（SortObject*p，unsignedlong*compare,unsignedlong*exchange）

{

inti,j;

RecordNodetemp；

SortObject*pvector；

if（（pvector=（SortObject*）malloc（sizeof（SortObject）））==NULL）

｛

printf（”OverFollow！

"

）;

getchar（）;

exit

（1）;

｝

for（i=0;

i<

p—>

n;

i++）/*复制数组*/

pvector->

record［i]=p—〉record［i];

pvector-〉n=p—〉n；

*compare=0；

＊exchange=0；

for（i=1；

pvector->

n；

i++）

｛temp=pvector->

record［i];

（*exchange）++;

j=i—1;

while（（temp.key〈pvector->

record［j].key）&

＆（j〉=0））

｛（＊compare）++;

（*exchange）++；

pvector—>

record［j+1］=pvector—〉record［j］;

j-—；

if（j!

=（i-1））

｛pvector—>

record［j+1]=temp;

（＊exchange）++；

}

free（pvector）；

｝

voidSelectSort（SortObject＊p,unsignedlong*compare,unsignedlong*exchange）

{inti,j,k；

SortObject＊pvector;

printf（"

OverFollow!

）；

getchar（）；

for（i=0；

i〈p—〉n;

i++）/＊复制数组＊/

record［i］=p-〉record[i]；

n=p->

*exchange=0；

n—1;

｛k=i;

for（j=i+1;

j〈pvector—〉n；

j++）

｛（*compare）++；

if（pvector—>

record[j].key〈pvector—>

record[k]。

key）

k=j；

if（k!

=i）

｛temp=pvector-〉record[i］；

pvector-〉record[i]=pvector-〉record[k］;

record[k]=temp；

（*exchange）+=3;

voidBubbleSort（SortObject＊p,unsignedlong＊compare,unsignedlong*exchange）

｛inti,j,noswap；

if（（pvector=（SortObject＊）malloc（sizeof（SortObject）））==NULL）

｛printf（"

getchar（）;

exit

（1）；

p—〉n；

record［i]=p—>

record［i］;

pvector-〉n=p—>

｛noswap=1;

for（j=0;

j<

pvector—〉n—i—1；

{（＊compare）++；

if（pvector->

record［j+1］。

key<

record[j］。

{temp=pvector—>

record[j］;

pvector—〉record［j]=pvector—>

record［j+1];

record［j+1］=temp;

（＊exchange）+=3；

noswap=0；

｝

｝

if（noswap）break;

voidShellSort（SortObject＊p,intd,unsignedlong＊compare，unsignedlong＊exchange）

{inti，j,increment；

if（（pvector=（SortObject*）malloc（sizeof（SortObject）））==NULL）

{printf（"

”）;

getchar（）；

i〈p->

pvector—>

record［i]=p->

record［i]；

n=p—〉n;

＊exchange=0;

for（increment=d；

increment〉0；

increment/=2）

{

for（i=increment；

｛temp=pvector-〉record［i］;

（＊exchange）++；

j=i—increment;

while（j>

=0＆&

temp。

key〈pvector—>

record［j].key）

｛（*compare）++;

pvector—〉record[j+increment]=pvector-〉record[j]；

（＊exchange）++；

j-=increment;

pvector—〉record[j+increment］=temp;

（*exchange）++；

}

free（pvector）;

}

VoidSiftHeap（SortObject＊pvector，intsize,intp,unsignedlong＊compare,unsignedlong*exchange）

RecordNodetemp;

inti，child;

temp=pvector->

record[p];

（*exchange）++;

i=p;

child=2＊i+1；

while（child〈size）

if（child<

size-1＆＆pvector—〉record[child］。

key〈pvector-〉record[child+1].key）

（＊compare）++；

child++;

if（temp.key〈pvector->

record[child].key）

（*compare）++;

record[i］=pvector->

record［child]；

（＊exchange）++;

i=child;

elsebreak;

record[i]=temp；

voidHeapSort（SortObject＊p,unsignedlong*compare，unsignedlong＊exchange）

{inti,n;

OverFollow！

”）；

p-〉n；

record[i］；

＊compare=0；

n=pvector-〉n;

for（i=n/2—1;

i〉=0;

i——）

SiftHeap（pvector，n，i,compare，exchange）；

{temp=pvector-〉record[0];

pvector->

record［0］=pvector->

record［i］=temp；

（*exchange）+=3；

SiftHeap（pvector,i，0,compare，exchange）;

voidQuickSort（SortObject*pvector，intleft，intright，unsignedlong＊compare,unsignedlong*exchange）

｛inti，j;

if（left〉=right）

return;

i=left；

j=right;

temp=pvector—〉record[i］；

while（i！

=j）

｛while（（pvector-〉record［j]。

key〉=temp.key）&

&

（j>

i））

｛（＊compare）++;

j--；

if（i<

j）

{

pvector—>

record［i++]=pvector—>

record［j］;

（＊exchange）++;

while（（pvector-〉record[i].key〈=temp.key）&

＆（j〉i））

｛

（＊compare）++;

i++;

if（i<

pvector-〉record［j-—]=pvector-〉record[i］；

pvector—〉record[i］=temp;

（＊exchange）++;

QuickSort（pvector,left,i—1,compare，exchange）;

QuickSort（pvector，i+1,right，compare,exchange）；

voidSortMethod（void）

{inti,j；

unsignedlongnum［3］[12］=｛0}；

SortObject＊pvector=（SortObject*）malloc（sizeof（SortObject））；

intrandom；

randomize（）；

for（j=0；

j〈3；

{for（i=0；

MAXSORTNUM[j]；

record[i］.key=random（5000）；

n=MAXSORTNUM［j］;

InsertSort（pvector，＆num[j]［0],＆num［j]［1］）；

SelectSort（pvector，&

num［j][2],＆num［j][3］）;

BubbleSort（pvector，&

num［j][4]，＆num[j］[5］）；

ShellSort（pvector,4，&

num［j］[6］,&

num[j］［7］）;

Heapsort（pvector,＆num［j］[8]，＆num［j][9]）；

QuickSort（pvector，0，MAXSORTNUM［j］—1，＆num［j][10],&

num［j］［11]）;

printf（"

\nSortMethodCompareAsFollows：

printf