七种排序算法比较及每种排序上机统计时间

七种排序算法的比较及每种排序的上机统计时间

七种排序算法的比较及每种排序的上机统计时间

七种排序算法的比较及每种排序的上机统计时间

《数据结构》课程设计报告

课题:　　排序算法的比较

学院:信息学院

班级: 　２011级电子信息工程1班

小组成员：韦志东(组长) 2２7 　

?夏琪 　　 　 　 228

完成时间: 2014-01-0８

教师:周铁

目录

ＴOC \o ＂1-3" \h \z ＼ｕ HYPＥRLINＫ 1.1、选题?2

HＹPERＬＩNＫ ＼ｌ "_Ｔoｃ2６4２08４9９"　1．2、选题的意义及背景 2

　　 　 1.3、设计任务书………………………………………………………………2

　ＨYPERＬINK　＼l　"_Toｃ2642０８501" 2、设计分析?２

HYＰERLINＫ　2.１、原始数据? PＡGEＲＥF ＿Toｃ264２08502 \h 2

HYPERＬＩＮK 2．2、输出数据 PＡＧEREF _Toc2６4２08503 \ｈ 2

HYPERLＩNK \ｌ　"_Toc26４２08504" 2．3、程序流程图?３

HYＰERLINK \l　＂_Tｏｃ264208511"　3、程序源代码及注释?3

HYPEＲLINK ＼l "＿Toc2642０8５1３＂　4、测试结果 PＡＧEＲEF _Tｏc2642０8５13　\ｈ １2

HYＰERLＩNK ＼l "_Toc26420851６＂ 5、总结?2６

HYPERLINＫ　6、参考文献 2７

HYPERＬINＫ　\l ＂_Tｏc26４２08518" 7、小组人员分工 27

1、课程分析

1.１、选题要求

利用随机函数产生３0000个随机整数，利用直接插入排序、希尔排序,冒泡排序、直接选择排序、快速排序、堆排序、归并排序的排序方法进行排序,并统计每一种排序上机所花费的时间。

1.2、选题的意义及背景

排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素的任意序列，重新排列成一个按关键词有序的序列。

此实验通过对各种内部排序算法进行比较,能使我们更好的掌握各种排序的基本思想,掌握各种排序方法的算法实现，掌握各种排序方法的优劣分析及花费的时间的计算，掌握各种排序方法所适应的不同场合。通过该题目的设计,可以加深理解各种数据结构的逻辑结构、存储结构及相应上运算的实现，进一步理解和熟练掌握课本中所学的各种数据结构,学会如何把学到的知识用于解决实际问题，培养我们的动手能力。

１.3、设计任务书

（1)定义结构体，头文件,定义数组范围，大小。

(2)依次描写七种排序的算法。

（３)描写产生随机函数的算法。

(4)描写菜单函数。

(５）描写主函数,调用七种排序的算法。

2、设计分析

2．1 原始资料

用户输入记录的个数３0000个,数据由随机函数生成。

2．2 输出数据

产生的随机数分别用冒泡排序、直插排序、希尔排序、选择排序、快速排序、堆排序、归并排序这些排序方法进行排序,并统计每一种排序上机所花费的时间。

2.3 程序流程图

主程序

主程序

产生1

产生1组随机数

将随机数保存在数组中

将随机数保存在数组中

二路归并排序冒泡排序

二路归并排序

冒泡

排序

直接插入排序

堆排序直接选择排序快速排序Shell

堆排序

直接选择排序

快速排序

Shell排序

输出排序上机所花费

输出排序上机所花费的时间

３.程序源代码及其注释

#inclｕde　"stｄio．ｈ＂

＃inｃｌｕｄｅ　＂ｓtdlib.ｈ＂

#ｉｎcludｅ "mａth.h"

＃incｌude<time.h>

＃include<coｎio.h>

#defｉnｅ MAX 6００00 /*记录数组的个数*/

＃ｄeｆｉne NＵM 300０0 /*实际输入数组的个数＊/

typeｄef　int datａtｙpe;

ｔypedef sｔrｕｃt /*定义记录为结构体类型＊/　

{ inｔ keｙ; 　 /*记录的关键词域＊/

ｄaｔatypｅ otheｒ; /*记录的其它域*/

} reｃtype;

rｅctｙpe *s1,s[MＡX］；/＊s［MAX]存放原始随机数，*ｓ1取出原始数据后进行排序*／

／*直接插入排序算法如下*/

voiｄ inserｔ_soｒt(rectyｐe ＊r) /*对数组r按递增顺序进行插入排序算法*/

｛　 inｔ　i,ｊ,ｎ＝NUM； 　　 ／*NUM为实际输入的记录数,是一个常量＊/

　 for(i=1；i<＝n;i++） 　 ／* i<NＵM 条件很重要,NUM为实际记录数＊/

?{ r[0］=r[i]; 　　 　 /＊r[0]为监视哨*／

　 　 j=i-１;　　　 　 　 ／*依次插入记录ｒ[1］,……，ｒ[NUM］*/

wｈiｌe(r[0].kｅy＜ｒ[j]．ｋｅy） /*查找r[i］合适的位置*/

? {ｒ[ｊ+1]=r［j--]；} 　 　 ／*将记录关键词大于r[i］.key的记录后移*/

　 r[j＋1]＝r［0]； 　 　 　　 　 ／*将记录r[i]插入到有序表的合适的位置上＊/

｝

}／*INSERTSORT*/

／＊希尔排序算法如下*／

void　shelｌ_ｓort(rｅctyｐe ＊r) /*取增量为ｄ(ｉ+1)=[ｄ(i)/2]的希尔排序的算法*/

{ ｉnt　i，ｎ,jｕｍp,ｃｈａnge,temp,m； ／*change为交换标志，jump为增量步长*／

　 　juｍp=NUM； n=ＮＵＭ; ／*NUM为顺序表的实际长度*/

　　　while(jump>0）

?　｛　jumｐ＝ｊｕmp／2; /*取步长d(ｉ+１)＝[d(i)/２］*／

　 do ｛ changｅ=0； /*设置交换标志，ｃhanｇｅ=0表示未交换*/

　 for(i=１;i<＝ｎ-ｊｕｍp;i++）

{ m＝i+jｕmｐ; /＊取本趟的增量*/

? 　　 　　　 　 　 if（r[i].key>r[m].kｅy) ／＊记录交换*/

{　temp=r[m］．keｙ；

　 　 　　　 　 r［m]．kｅy=r[i].ｋey；

　　 ? 　　 r[i］.keｙ=teｍp;

　 　 　 cｈanｇｅ=１;　/＊ｃhａｎge=１表示有交换*/

? 　}/*if*／

}／*for*/　/＊本趟排序完成*／

? 　｝whｉle(change==1); /*当ｃhange=０时终止本趟排序＊/

}／*wｈｉlｅ*/? /*当增量jｕmp=1且cｈanｇe=０时终止算法*/

｝／*SHＥLLSＯRT＊/

／*冒泡排序算法如下＊/

voｉd bubble_soｒt(ｒｅcｔyｐe *ｒ)　／*从下往上扫描的冒泡排序*/

{ inｔ i,j,nos； /*noswａｐ为交换标志,NUＭ为实际输入记录数*/

rｅｃtｙpe temp；

fｏｒ（i＝1;ｉ＜n;ｉ＋+)? 　/＊进行n－1趟冒泡排序＊/

{ ｎｏswaｐ=1; /＊设置交换标志，ｎｏｓwap＝１表示没有记录交换*/

for(j=ｎ;j>=i；j--) /*从下往上扫描*/

　if(r［ｊ].key＜ｒ［ｊ－1].ｋeｙ)?／*交换记录*/

　{ tｅｍp．kｅｙ=r［j-１］.ｋey;

ｒ[j－１].ｋey=ｒ[j].ｋeｙ;

r[j]．ｋｅy＝ｔemp.key;

ｎoswap＝0; ／＊当交换记录时，将交换标志置0即noｓｗap＝０ */

}/*ｉf＊/

ｉf(nｏswap) bｒｅak; /*若本趟排序中未发生记录交换，则终止排序*/

｝/*for*/ ? /＊终止排序算法*/

}/*BUBBLESORＴ*/

/*快速排序算法如下＊/

ｉnt partitｉon(reｃtype　*r,ｉｎt s，int t) /*快速排序算法中的一趟划分函数*/

｛　ｉnt i,j；rectype ｔemｐ;

i=s；j=t;teｍp=r［i]；　　 　 　 　 　 　　 /*初始化，ｔｅmｐ为基准记录＊/

dｏ {while((r［j］.key＞＝tｅmp．kｅy）&&(i<j))

　 j--; /＊从右往左扫描,查找第一个关键词小于tｅmp的记录*/

if(i＜j) r[i++]=r[j]; /*交换r[i]和ｒ[j］*/

whｉlｅ（(ｒ[i］.key<=tｅmp.kｅy)&&(i<j))

　 　 i++；? /*从左往右扫描,查找第一个关键词大于temp的记录＊/

if(i<j) r［j--]=r[i］； /*交换r［ｉ]和r[j]＊／

}while(i!=j);/*i=j,z则一次划分结束,基准记录达到其最终位置＊/

r[ｉ]＝ｔｅmp; /＊最后将基准记录temp定位*/

ｒetuｒn(i);

}/＊PＡRTITIOＮ＊／

ｖｏid quick_ｓoｒt(recｔyｐe *r,int　hs,int ht)/*对r[hs]到r[ht]进行快速排序*/

{　inｔ ｉ;

if（ｈs<ｈｔ) ／*只有一个记录或无记录时无需排序*/

｛ i=paｒtitｉon（r,hs,ht）； /＊对r[hs］到r[ｈｔ]进行一次划分*／

　　ｑｕicｋ_sort(r,ｈs,ｉ－1）;?／*递归处理左区间*/

qｕick_sort（ｒ,i+１,ht);?/＊递归处理右区间*／

｝

}/＊QUIＣK_SORＴ＊／

／*直接选择排序算法如下*/

void ｓelect_sorｔ(ｒectyｐe *r） 　　　　

{　reｃtypｅ teｍｐ;

int i,j，ｋ,n=NUM; /＊NUM为实际输入记录数*/

foｒ(i=1；i<=n；i++)/*做ｎ-１趟选择排序＊/

{ k＝i;

fｏr（ｊ＝ｉ+１；j<=n;ｊ+＋)/*在当前无序区中选择关键词最小的记录r[k]*/

iｆ(r[ｊ］．key＜r［ｋ]．key) ｋ=j;

if(k!=i）　{temp＝ｒ[i];/*交换记录r[ｉ]和r[k]*/

　 　 　r[i］＝ｒ［k]；

? 　r［k]=teｍp;

　 }

}/*for*/

｝/*ＳEＬECT＿SORT*／

/*堆排序算法如下*/

vｏｉd shｉｆt(rectyｐe ＊ｒ,ｉnｔ i，int ｍ）/*堆的筛选算法,在数组中r[ｉ］到ｒ［m]中，调整堆r[ｉ]＊／

{ inｔ　j;　rectype temp;

ｔeｍp=r［i]; j＝2*ｉ;

while (ｊ<=m）／*j<=m,ｒ[2*ｉ］是r[i]的左孩子*/

　 {　if((ｊ<ｍ）&&（r[j].kｅy<ｒ［ｊ＋1]．ｋeｙ）)

　 　 ｊ++; ／*j指向r[i]的左右孩子中关键词较大者*/

if(ｔeｍp．ｋey<r[j].kｅｙ) /*若孩子结点的关键词大于父结点*/

?｛ 　r［i]=ｒ［j]; 　 /*将r［j］调到父亲结点的位置上*／

? 　 ｉ=j； 　/*调整i和ｊ的值,以便继续“筛”结点*/

　　 　 j=2＊i；

}

　 eｌｓe

ｊ=m+２; ? 　/*调整完毕，退出循环＊/

}

ｒ[i]=temｐ; ? /＊将被筛选的结点放入正确的位置*/

｝/*SHIFT*/

vｏid heaｐ_sorｔ(rｅｃtype *ｒ）/*对数组ｒ[1]到r[NUM]进行堆排序*/ 　 　　 　 　 　 　

{ 　　rectypｅ temp;　

?iｎｔ　i，n;

　 n＝ＮUM; 　 ／*NUM为数组的实际长度*/

　for(i＝n/2;i>０;i--)/*建立初始堆＊/

shiｆt(r,ｉ,n);

　for(ｉ＝n；i>1；i--）/*进行n-1趟筛选,交换,调整，完成堆排序*/

{　temp=r［1];／*将堆顶元素r[1]与最后一个元素交换位置＊/

　ｒ[1］＝r[ｉ];

ｒ［i]=teｍｐ;

?shiｆｔ(ｒ,１,ｉ-1);/*将数组元素ｒ[1]到ｒ[i－1]重新调整成为一个新堆*/

}／*ＦOR*/

}/*HEAP_ＳＯRT＊/

/*二路归并排序算法如下*/

voiｄ merge(ｒectype *a，reｃtypｅ *r,int loｗ,int ｍid,int ｈigh)

{ int　i，ｊ，k;

ｉ＝lｏw;j＝mid+1;k＝low;

whiｌe((i＜=miｄ)＆&(j<=higｈ）)／*将两个相邻有序子表进行合并*/

{　ｉf(ａ［i].kｅy<=a[j］.key）/*取两表中小者复制*／

r［k++]＝a[i++]；

else r[k+＋]＝a[j++];

｝

ｗhile(i＜=mid) r[k+＋］=a[i＋＋］;／*复制第一个有序子表的剩余记录*/

whilｅ(j＜=hiｇｈ) r[ｋ+＋]=a[j＋+]；/＊复制第二个有序子表的剩余记录*／

}/*MERＧE*／

ｖoid merge_ｐasｓ(recｔｙｐe　*r,rectype　＊r1,ｉnｔ lｅngｔh)

｛ iｎt　i=1,j,n=ＮＵＭ;

ｗhiｌｅ　((i+2＊lｅnｇth-1)＜＝n)／*归并若干长度为2*length的两个相邻有序子表＊/

{　ｍｅrge(r,r1,i，i+lengtｈ-１，ｉ+２*lｅnｇtｈ-1)；

　 i=i+2*lenｇth;/＊ｉ指向下一对有序子表的起点*/

｝

if(ｉ+ｌength－１<n）

merge(r,r1，ｉ,i＋lｅngｔh-1，n);/*处理表长不足2*ｌeｎｇth的部分＊/

elsｅ foｒ(ｊ＝i;j<=n；j++)

　　 r１［j]=r[j];/*将最后一个子表复制到ｒ１中*／

｝／＊MERGEPASS*/

vｏiｄ mｅrge_soｒｔ（rectype *r）

{ inｔ ｌｅngth;

rｅｃtｙpe r1[MAX]；

　length=1;/*归并长度从１开始*/

ｗhile(ｌｅngｔh<ＮUM)

{　merｇe_ｐａsｓ（ｒ,r1,length）；/＊一趟归并，结果存放在r1中＊/

ｌengｔh=２＊ｌength;/＊归并后有序表的长度加倍＊／

mｅrgｅ＿ｐass（r1，r,ｌength);/*再次归并，结果存放在ｒ中＊／

　 lｅnｇth=2＊lenｇth；／*再次将归并后有序表的长度加倍＊/

　}

｝/*MEＲＧE_ＳORT*/

void creat＿ranｄnum（ｉnt ＊a )/*产生给定个数和范围的随机整数函数＊/

｛ int ｉ；

iｎt range=３0０0０;

sｒａnd(tｉme（ＮULL));

fｏr(ｉ=１;ｉ<＝NUM;i++)

｛a[ｉ]=ｒand();} /＊调用ｒand生成随机整数*/

ｐrintf("\n＼n\ｔ\t\t排序前的原始随机整数为：\ｎ\n＼t");

for(i=1;ｉ<=NUM；i++)

{ priｎｔf("%6d＂，a[i］);　／*输出随机整数＊／

　 iｆ（ｉ%10==0) priｎｔｆ（"\ｎ＼t");

｝prｉｎtf("\n")；

}/*CREＡT_ＲANDNＵM*/

void create() /*产生NUM个随机整数并保存到记录数组s中*／

｛ int ｂ[ＭＡX]；

iｎt ranｇe=300００,i；

cｒeａt_ｒandnum(ｂ); /＊调用随机整数生成函数，结果存放在数组ｂ中＊／

　for(i=１；i＜=NUM；ｉ＋＋)

? ｓ［i］.key＝b［i]；／*将随机整数存放到数组ｓ中*／

　ｓ1=ｓ;/＊ｓ１指向s,以便保存原始数据*/

}/*CＲEAT*/

ｖoiｄ print_rｅｃord(ｒｅctyｐｅ *ｒ)／*记录数组的输出函数*/

{ int i；

pｒintf("\ｎ＼t＼t\ｔ排序后的有序随机整数：\n\n\t＂);

foｒ(ｉ=1;i<＝NUM;i++)

{printｆ(＂％6d＂，r[i].key);

　iｆ（i%1０==0) priｎｔｆ("＼ｎ＼n\ｔ"）；

}getcｈar（);gｅtｃhaｒ（)；

}/*ＰRＩNTRECORＤ*／

ｉnt　menu_seｌect()/*主菜单选择模块*/

{ cｈar ｃ; int ｋk;

system（"cls")；/*清屏函数*/

priｎtf("内排序算法的比较-－--主控模块：\ｎ\n");

pｒiｎtf("\t\ｔ\t1. 直接插入排序＼ｎ")；

prinｔf(＂＼t＼t\t2． 希尔排序\ｎ");

ｐrｉntf("\t＼ｔ\t3. 冒泡排序\n＂);

prｉntf("\t＼t\ｔ４. 快速排序\n");

ｐrｉnｔf（"＼t\ｔ\t5.　直接选择排序＼n");

prinｔｆ("\t\t\t６. 堆排序\ｎ");

prｉnｔｆ(＂\t＼t\t7． 二路归并排序＼n");

pｒｉｎtf("\t＼ｔ\t０. 退出\n")；

do {printf("\n\t＼t\ｔ请按数位0—7键选择功能：＂）;

c=geｔcｈａr(）;　kｋ=c-48；

}ｗhｉle ((kk＜０）||(kｋ）>7);

ｒｅturｎ（ｋk);

}/＊MENU_SEＬＥＣT*/

mａin（） 　/*算法比较--主程序模块*/

{ 　

doubｌｅ　 ｔｉme1, tiｍe2, ｔｉme3, time４，　time5, tｉme6, tiｍｅ７；

　 ｃｌock＿t stａrt，　finisｈ;

inｔ kｋ；

　　 ｄo　{ｋk＝mｅnu_select(）; /*进入主菜单选择模块*/

　 if(kk!＝0) cｒｅａｔe(); /*建立记录数组＊/

swｉｔch(ｋk)

{ case 1：{?sｔaｒt＝clocｋ（)；

? insｅrt_sorｔ(s１）;

? finish＝clocｋ(）;

time1 ＝ (double)(finｉｓh - stａｒt）/ CＬOCKS_PEＲ_SEＣ　;

ｐriｎtf( "直接插入排序耗时%f ｓｅcoｎｄs\n"， tiｍe1);　 bｒeａk；}

case 2:{ ｓｔarｔ=cloｃk();

? ? sheｌl_ｓoｒt(ｓ１);

?ｆiｎiｓｈ=cｌｏcｋ();

time2 =　(doubｌe）(ｆinish - sｔart)/　ＣＬOCKS_PER_SEＣ ;

prinｔｆ（ "希尔排序耗时%f sｅcｏnds\n"， time2); 　 　 　breaｋ;}

　 　 casｅ 3:{ stａｒt=clock();

bubblｅ_sorｔ(s1)；

? fiｎｉsh=clocｋ（）;

?time３ =　(ｄoublｅ)（fiｎish － starｔ)／ CＬＯCKS_PER_ＳEC ;

prｉｎtf( "冒泡排序耗时%f　secｏnｄs\n＂， tiｍe3)；　 　　 bｒeaｋ;} 　　

　 cａｓｅ 4:{ 　 stａrｔ＝cｌock();

ｑuｉcｋ_sｏrt(s1,1，NUM）；

? ?fｉnｉsｈ=ｃlock();

? time4 ＝ (ｄoubｌe)(finish - ｓｔaｒt）/　ＣLＯCKS_PＥR_SEC；

? ?prｉntf( "快速排序耗时%ｆ secoｎｄs\n＂， time４);　　 　 ｂreak；｝

? 　case 5:{ 　 start=clocｋ()；

? ?selｅct＿sｏｒｔ(ｓ1）；　

fｉniｓh＝cloｃk(）；

? tiｍe5　= (ｄｏuｂｌe)（ｆinisｈ　－ start)/ CＬOCKS_PER＿SEC ;

?printf( "直接选择排序耗时%f seconds\n", tｉme５）; 　 breaｋ；｝ 　

? ｃase 6:{ 　　 staｒｔ＝cloｃk（);

? hｅａp_sｏrt(s1）;

? ｆiniｓｈ=cloｃk();

?time6 ＝ (ｄoubｌｅ)（finiｓh - sｔart)／ CＬOCKS_PER_ＳＥC ;

?pｒiｎｔf( "堆排序耗时%ｆ secondｓ\n"， ｔime6）; 　　 break；}

　　　 case 7:{　　 sｔarｔ＝ｃｌoｃk()；

? 　 　　ｍerge_sort(ｓ1);　　

fiｎiｓh=cｌoｃk();

? time7 ＝ （ｄouble)(finｉsh - stａｒｔ)/ CLOＣＫＳ_PER_ＳEC ;

? ｐrinｔf（ ＂二路归并排序耗时%f seconｄs＼n＂， tｉｍe7); 　 bｒｅａk;} 　

　ｃａse　0:{ 　 　 　　ｅxit(0）;｝

?}prinｔ_rｅcord(s1);

}while (ｋｋ!=0)；

}/*MAIＮ*/

4．测试结果

（１）选择直接插入排序:

排序前本有30０00个随机数显示，但数据太多,只截一部分图来表示。

排序后也一样,应有３0000个排好顺序的整数显示，但由于数据过多,也只截一部分图来表示。

由图可知，直接插入排序耗时０.878000秒

(2)选择希尔排序：

排序前本有30000个随机数显示，但数据太多,只截一部分图来表示。

排序后也一样,应有3０00０个排好顺序的整数显示,但由于数据过多,也只截一部分图来表示。

由图可知,希尔排序耗时0．0２60０0秒

(3）选择冒泡排序：

排序前本有3０000个随机数显示,但数据太多,只截一部分图来表示。

排序后也一样,应有3000０个排好顺序的整数显示，但由于数据过多，也只截一部分图来表示。

由图可知,冒泡排序耗时３.4560０0秒

（4）选择快速排序:

排序前本有3００00个随机数显示，但数据太多，只截一部分图来表示。

排序后也一样,应有3００００个排好顺序的整数显示，但由于数据过多，也只截一部分图来表示。

由图可知,快速排序耗时0.0０50０0秒

（５）选择直接选择排序:

排序前本有30000个随机数显示,但数据太多，只截一部分图来表示。

排序后也一样，应有30000个排好顺序的整数显示，但由于数据过多，也只截一部分图来表示。

由图可知,直接选择排序耗时1.5２８000秒

(6）选择堆排序:

排序前本有30０0０个随机数显示，但数据太多,只截一部分图来表示。

排序后也一样,应有３0000个排好顺序的整数显示,但由于数据过多,也只截一部分图来表示。

由图可知,堆排序耗时0.00８00０秒

(7)选择二路归并排序:

排序前本有３００00个随机数显示，但数据太多，只截一部分图来表示。

排序后也一样,应有3000０个排好顺序的整数显示，但由于数据过多,也只截一部分图来表示。

由图可知，二路归并排序耗时０.00６000秒

5.总结与体会

总结:由上述比较我们可以清楚地知道，各种排序算法之间的差别是很大的。其中在这几种不同的算法中，快速排序是其中最快的一种排序算法,其它几种算法都有些差异，其中冒泡排序最慢。

通过实验设计,我们可以明确感受一些内部排序方法选择的规则，其主要是（1)当n较小时：可采用直接插入排序和直接选择排序；(2)当记录规模小时，可选择直接插入排序；当记录规模大时，可选择直接选择排序,因为直接插入排序所需的记录移动操作比直接选择排序多;(３）当记录基本有序时：可采用直接插入排序和冒泡排序；（4)当n较大时：可采用快速排序和归并排序。

体会:通过此次的课程设计,让我从中得到了许多锻炼,也学到了许多东西。通过对排序算法的比较的设计,我更加深入地理解了算法的思想与原理，也深切地感受各种算法的运行时间长短,体会到它的优缺点,并且充分锻炼了我的动手能力,把理论与实践相结合，把学到的知识用于解决实际的问题。而且，通过设计的操作，让我体会到了一个人力量的渺小,充分感受到了团队协作的力量,大家一起相互讨论，积极沟通，相互学习，相互帮助,锻炼了我的协作能力。还有对于编程来说，让我体会到了看书很重要,但实在在动手去做才是硬道理,特别在调试的时候,要有足够的耐心与亲自不断尝试的能力，还有编程一定养成良好的编程习惯，无论命名还是结构。尽管还有很多地方有待提高和改正，不管怎样通过此次的课程设计我受益匪浅,积累了经验，锻炼了自己分析问题、解决问题的能力。

6.参考文献

[1]秦锋、袁志祥.数据结构（C语言版）例题详解与课程设计指导.北京:清华大学出版社

[2］百度文库　 　 HYPＥRLINK "hｔtｐ：//＂ ｗww. Wenku.ｂａidu,cｏm

[3］． 严蔚敏，吴伟民，　《数据结构（C语言版）》,清华大学出版社,20０９

７．小组人员分工

组长:韦志东

组员:夏琪

分工: 韦志东：主程序、随机函数生产、报告撰写

夏琪:直接插入排序，希尔排序,冒泡排序，直接选择,,快速排序,堆排序,归并排序，数据记录。