数据结构课程设计内部排序算法比较docWord下载.docx

数据结构课程设计内部排序算法比较docWord下载.docx

《数据结构课程设计内部排序算法比较docWord下载.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计内部排序算法比较docWord下载.docx（14页珍藏版）》请在冰豆网上搜索。

时间的估算：

六、参考文献12

七、实训体会12

姓名：

学号：

联系方式：

内部排序算法比较

一、问题描述

排序是数据结构中重要的一个部分，也是在实际开发中易遇到的问题，所以研究各种排算法的时间消耗对于在实际应用当中很有必要通过分析实际结合算法的特性进行选择和使用哪种算法可以使实际问题得到更好更充分的解决！

该系统通过对各种内部排序算法如直接插入排序，冒泡排序，简单选择排序，快速排序，希尔排序，堆排序、二路归并排序等，以关键码的比较次数和移动次数分析其特点，并进行比较，估算每种算法的时间消耗，从而比较各种算法的优劣和使用情况！

排序表的数据是多种不同的情况，如随机产生数据、极端的数据如已是正序或逆序数据。

比较的结果用一个直方图表示。

二、系统分析

界面的设计如图所示：

|*****************************|

|--------欢迎使用-------|

|------

（1）随机取数-----|

|------

（2）自行输入-----|

|------（0）退出使用-----|

请选择操作方式：

如上图所示该系统的功能有：

（1）：

选择1时系统由客户输入要进行测试的元素个数由电脑随机选取数字进行各种排序结果得到准确的比较和移动次数并打印出结果。

（2）选择2时系统由客户自己输入要进行测试的元素进行各种排序结果得到准确的比较和移动次数并打印出结果。

（3）选择0打印“谢谢使用！

！

”退出系统的使用！

三、系统设计

|******************************|

|-------欢迎使用---------|

|-----

（1）随机取数-------|

|-----

（2）自行输入-------|

|-----（0）退出使用-------|

|******************************|

（用户在此输入操作方式）

（3）系统采用定义结构体数组来存储数据

①操作功能：

a.当用户选择随即电脑随机取数时

系统将弹出——>

请输入你要输入的个数：

（用户在此输入要电脑取数的个数）要是用户输入的数据过大系统将提醒错误——>

超出范围重新输入!

!

b..当用户选择自行输入时

系统将弹出——>

请输入你要输入的个数（不大于于30的整数）：

当用户输完元素的个数之后系统将提示用户依次输入各个元素。

——>

请输入各个元素:

②排序功能：

系统有简单选择排序，冒泡排序，堆排序，二路归并排序，快速排序的功能。

③打印清晰：

系统会打印出在排序操作之前电脑随机取数或者用户输入的原始排列顺序；

并将排序操作之后的有序数据打印在原始数据的下面以便用户的对比。

在排序操作结束之后系统将以直方图的形式打出排序过程中比较和移动次数让客户一目了然地看到排序的结果：

比较结果

排序方式

比较次数

移动次数

直接

简单选择

冒泡

堆排序

归并

快速

四、系统实现

定义结构体数组

typedefstruct

{intkey;

}datatype;

datatypeR[MAXNUM];

//定义结构体数组

直接排序

voidD_InsertSort（datatypeR[],intn）//直接排序

{

inti,j;

for（i=2;

i<

=n;

i++）

{cn[0]++;

if（R[i].key<

R[i-1].key）

{R[0]=R[i];

mn[0]++;

for（j=i-1;

R[0].key<

R[j].key;

j--）

R[j+1]=R[j];

R[j+1]=R[0];

mn[0]+=2;

}

}

简单选择排序

voidSelect_Sort（datatypeR[],intn）//简单选择排序

{

inti,j,k;

for（i=1;

i<

n;

i++）

{k=i;

for（j=i+1;

j<

j++）

{

cn[1]++;

if（R[j].key<

R[k].key）

k=j;

}

if（i=k）

{R[0]=R[k];

R[k]=R[i];

R[i]=R[0];

mn[1]+=3;

冒泡排序

voidBubble_Sort（datatypeR[],intn）//冒泡排序

inti,j;

intswap;

for（i=1;

n-1;

{swap=0;

for（j=1;

=n-i;

cn[2]++;

if（R[j].key<

R[j+1].key）

{R[0]=R[j];

R[j]=R[j+1];

mn[2]+=3;

swap=1;

}}

if（swap==0）break;

堆排序

voidHeapAdjust（datatypeR[],ints,intt）

datatyperc;

inti,j;

rc=R[s];

i=s;

for（j=2*i;

=t;

j=2*j）

{cn[3]++;

if（j<

t&

&

R[j].key<

R[j+1].key）j=j+1;

if（rc.key>

R[j].key）break;

R[i]=R[j];

mn[3]++;

i=j;

R[i]=rc;

voidHeapSort（datatypeR[],intn）//堆排序

inti;

for（i=n/2;

i>

0;

i--）

HeapAdjust（R,i,n）;

for（i=n;

1;

i--）

{R[0]=R[1];

R[1]=R[i];

mn[3]+=3;

HeapAdjust（R,1,i-1）;

归并排序

voidMerge（datatypeR[],datatypeR1[],ints,intm,intt）

j=m+1;

k=s;

while（i<

=m&

j<

=t）

cn[4]++;

if（R[i].key<

R[j].key）

{R1[k++]=R[i++];

mn[4]++;

else

{R1[k++]=R[j++];

=m）{R1[k++]=R[i++];

while（j<

=t）{R1[k++]=R[j++];

voidMSort（datatypeR[],datatypeR1[],ints,intt）

intm;

if（s==t）{R1[s]=R[s];

else{m=（s+t）/2;

MSort（R,R1,s,m）;

MSort（R,R1,m+1,t）;

Merge（R1,R,s,m,t）;

voidMergeSort（datatypeR[],datatypeR1[],intn）//归并排序

MSort（R,R1,1,n）;

intPartition（datatypeR[],intlow,inthigh）

R[0]=R[low];

mn[5]++;

while（low<

high）

{while（low<

high&

R[high].key>

=R[0].key）{cn[5]++;

high--;

if（low<

high）{R[low]=R[high];

low++;

R[low].key<

R[0].key）{mn[5]++;

high）{R[high]=R[low];

R[low]=R[0];

returnlow;

快速排序

voidQuick_Sort（datatypeR[],ints,intt）//快速排序

if（s<

t）

i=Partition（R,s,t）;

Quick_Sort（R,s,i-1）;

Quick_Sort（R,i+1,t）;

voidprin（datatypeR[],intn）

inti;

printf（"

排序的结果为：

"

）;

%d"

R[i]）;

\n"

}

电脑随机取数

voidsui_ji（）

inti,n;

datatypeR[MAXNUM]={0};

a:

请输入你要输入的个数:

scanf（"

%d"

&

n）;

if（n>

25）

\n"

gotoa;

addlist（R,n）;

排序前元素顺序为:

n+1;

i++）printf（"

R[i].key）;

D_InsertSort（R,n）;

//直接排序

prin（R,n）;

Select_Sort（R,n）;

//简单选择排序

Bubble_Sort（R,n）;

//冒泡排序

HeapSort（R,n）;

//堆排序

datatypeR1[MAXNUM]=