《数据结构》 内 排 序 算 法分析.docx
《《数据结构》 内 排 序 算 法分析.docx》由会员分享，可在线阅读，更多相关《《数据结构》 内 排 序 算 法分析.docx（30页珍藏版）》请在冰豆网上搜索。
《数据结构》内排序算法分析
《数据结构》
课程设计报告
设计题目内排序算法
学院名称
专业班级
姓名
学号
目录
一、实验题目1
内排序算法1
二、问题描述1
三、设计目标1
四、需求分析1
五、概要设计1
六、函数2
流程图3
七、测试分析4
八、使用说明7
九、课程设计总结8
十、附录（各功能函数源代码）9
1、实验题目
内排序算法
二、问题描述
要求从外部文件读入或直接输入数据，编写一程序，通过插入、选择、交换、归并、基数等方法进行数据的排序。
三、设计目标
设计一个程序，利用内排序各算法，如直接插入、希尔、冒泡、直接接择、基数、归并、堆排序等算法进行数据排序，输出每趟排序结果，让排序算法更加明了，大大提高排序效率，缩短时间的花费。
四、需求分析
本次试验主要分为以下四大功能模块：
1）头文件：
定义全局变量，申明函数；
2）菜单：
各排序算法的分类；
3）算法：
对不同算法的描述定义；
4）主函数：
定义局部变量，调用各函数。
五、概要设计
1、各个模块功能的详细描述
voidinsetsort（intb[],intn）;//直接插入
voidsheelsort（intb[],intn）;//希尔排序
voidbinarysotr（intb[],intn）;//折半插入排序
voidselectsort（intb[],intn）;//简单选择排序
voidheapsort（intb[],intn）;//堆排序（完全二叉树）
voidbubblesort（intb[],intn）;//冒泡排序
voidquicksort（intb[],intlow,inthigh）;//快速排序
voidMerge（inta[],intlow,intmid,inthigh,intb[]）;//归并排序
voidjishu（intb[],intn）;//基数排序
2、系统结构功能图
六、函数
1、头文件
3、a、"h.h"
#include
#include
#include
#include
#include
#defineN10000int
g_flag;
b、“head.h”
#include
#include
#include
#include
#include
#defineMaxKeyNum12//最大关键字个数
#defineRadix10//关键字的基数
#defineMaxSize80//元素的个数
typedefintKeyType;//关键字类型为int型
typedefstruct
{
charkey[MaxKeyNum];
intnext;
}SListCell;//每个元素的关键字类型
typedefstruct
{
SListCelldata[MaxSize];
intkeynum,len;//关键字的个数及静态链表的长度
}SList;//静态链表类型
typedefintaddr[Radix];//定义静态指针数组类型
typedefstruct
{KeyTypekey;
}DataType;//元素类型*/
SListL;
DataTypea[MaxKeyNum];
2、主函数
#include"h.h"
#include"fp.c"
#include"mudex.c"
#include"Rad
#include"sort1.c"
voidmain（）
{intg_flag;
intb[N],n;
charch;
ixsort.c"
g_flag=0;
n=reaData（b）;
system（"modecon:
cols=170"）;//调整屏幕显示大小列、行
while
（1）
{
switch（nume（））
{
ch=getchar（）;
case1:
{
{
switch（insetr_mu（））
case'a':
insetsort（b,n）;
printData（b,n）;
system（"pause"）;
break;
case'b':
sheelsort（b,n）;//希尔排序//123
break;
case'c':
binarysotr（b,n）;//折半插入排序
break;
}
break;
}
case2:
{
switch（sele_mu（））
case'i':
selectsort（b,n）;//简单选择排序//123
printData（b,n）;
system（"pause"）;
break;
case'k':
heapsort（b,n）;//堆排序（完全二叉树）//123
break;
}
break;
case3:
{
switch（change_mu（））
case'!
':
bubblesort（b,n）;//冒泡排序
printData（b,n）;
system（"pause"）;
break;
case'y':
quicksort（b,0,n-1）;//快速排序
break;
}
break;
case4:
MergeSort（b,n）;//对数组中a元素进行归并排序
printData（b,n）;
system（"pause"）;
break;
case5:
jishu（b,n）;
printData（b,n）;
system（"pause"）;
break;
default:
printf（"error"）;
break;
}
}
}
2、流程图
1.求最大值
3、载入数据
2.文件的有关操作
4.直接插入排序
5.希尔排序
6.折半插入
7.简单选择排序
8.堆调整
七、测试分析
白盒：
黑盒：
a.显示主菜单；
b．选择“1.插入类”；
C.选择¡±a.直接插入排序¡±；
结论：
正常。
a.显示主菜单；
b．选择“2.选择类”；
C.选择“k.直接插入排序”；
结论：
正常。
a.显示主菜单；
b．选择“3.交换”；
C.选择¡±！
快速排序¡±；
结论：
正常。
a.显示主菜单；
b．选择“4.归并”；
结论：
正常。
a.显示主菜单；
b．选择“5.基数”；
结论：
正常。
八、使用说明
运行程序，在菜单界面，根据菜单的提示选择您想要实现的功能：
1：
插入类排序；
a：
直接插入类排序；
b：
折半排序；
c：
希尔排序；
2：
选择类排序；
i：
简单选择排序；
k：
堆排序；
3：
交换类排序；
！
：
快速排序；
y：
冒泡排序；
4：
归并类排序；
5：
基数排序。
九、课程设计总结
通过不断做课程设计，逐次有了一定的进步。
在这次课程设计中，又有了新的认识、理解，对于写程序，首先自己得先明确程序的目的，然后写一个大的框架，逐步向其添加实现自己想实现的功能的代码，对于每一行程序代码，要明白它是要实现哪一步，有什么功能，尽量的精简代码，让程序的效率提高。
当自己没有思路时，也可以去“继承”别人的代码，对于现成的代码，理解上就得严格把关，多次去想代码的运行，思路跟随代码，仔细的将代码大体化，进而细化，在这个过程中，调试是一个很好的方法，每一步的调试，都可以清楚的了解每一个变量随时变化的值，以便能彻底的了解程序。
实在是不能理解，就可以动手写，将程序代码的每一步执行运算后的结果写在纸上，通过不断的对比去加深对代码的理解与运用。
与此同时，也要和别人交流，讲出你的代码，在别人不断的疑问与你的解答中，你会收获颇多，真正的让你知道你的不足！
进而深层次的挖掘代码。
十、附录（各功能函数源代码）
1、文件的操作
#include
intg_flag;
intreaData（intd[]）
{
FILE*fp;
inti=0;
intch;
fp=fopen（"data.txt","r"）;
if（NULL==fp）
{
return-1;
}
while（!
feof（fp））
{
fscanf（fp,"%d",&ch）;
d[i]=ch;
i++;}}
g_flag=1;
fclose（fp）;
returni;
}
intprintData（intd[],intn）
{inti=0;
if（g_flag<1）
{printf（"请先载入数据文件。
\n"）;
return0;}
for（;i{printf（"%d\t",d[i]）;
if（（i+1）%10==0）
printf（"\n"）;}
return0;}
1、菜单
#include
intnume（）
{intx;
printf（"\n\n"）;
system（"cls"）;
printf（"\t\t\t\t\t\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"）;
printf（"\t\t\t\t\t\t┃排序简介图┃\n"）;
printf（"\t\t\t\t\t\t┃注：
由上而下!
┃\n"）;
printf（"\t\t\t\t\t\t┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"）;
printf（"\t\t\t\t\t\t┃┏━━━━━━━━━━┓┃\n"）;
printf（"\t\t\t\t\t\t┃*内排序算法*┃\n"）;
printf（"\t\t\t\t\t\t┃┏━━━━┓┗━━━━*┳*━━━━┛┏━━━┓┃\n"）;
printf（"\t\t\t\t\t\t┃┏*1插入类*═┏━━━━┓*╩*═┳*════┳*══*3交换*┓┃\n"）;
printf（"\t\t\t\t\t\t┃║┗┳****┳┛*2选择类*┗══┓┏┛┗┳*━*┛║┃\n"）;
printf（"\t\t\t\t\t\t┃║║║┗*═┳*┳┛┏******┓║║║║┃\n"）;
printf（"\t\t\t\t\t\t┃║║║║┗═*堆*║║║║┃\n"）;
printf（"\t\t\t\t\t\t┃║║║┏**╩***┓┗******┛║║┏*╩****┓║┃\n"）;
printf（"\t\t\t\t\t\t┃║║┏**╩***┓*简单*║║*快速*║┃\n"）;
printf（"\t\t\t\t\t\t┃║║*希尔*┗*******┛║║┗*****═┛║┃\n"）;
printf（"\t\t\t\t\t\t┃║║┗*******┛║║║┃\n"）;
printf（"\t\t\t\t\t\t┃║║║║┏*******┓║┃\n"）;
printf（"\t\t\t\t\t\t┃║║┏*******┓┏═════┛┗┓*冒泡*┛┃\n"）;
printf（"\t\t\t\t\t\t┃║┗*直接*┏━┛━━┓║┗*******┛┃\n"）;
printf（"\t\t\t\t\t\t┃║┗*******┛*4归并*║┃\n"）;
printf（"\t\t\t\t\t\t┃┏╩****┓┗***═**━┛┏━━━╩┓┃\n"）;
printf（"\t\t\t\t\t\t┃*折半**5基数*┃\n"）;
printf（"\t\t\t\t\t\t┃┗******┛┗════┛┃\n"）;
printf（"\t\t\t\t\t\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"）;
printf（"\n\n\n\n"）;
printf（"输入你想要的排序方法：
"）;
scanf（"%d",&x）;
if（x<0&&x>6）
{
printf（"输入有误！
请重新输入（1~5）"）;
scanf（"%d",&x）;}
returnx;}
charinsetr_mu（）
{
charx;
printf（"\t\t\t\t\t\t┏━━━━━━━━━━━━━━━━━━┓\n"）;
printf（"\t\t\t\t\t\t┃━━━━━插入类排序━━━━━━━━┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃a.直接插入排序┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃b.折半排序┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃c.希尔排序┃\n"）;
printf（"\t\t\t\t\t\t┗━━━━━━━━━━━━━━━━━━┛\n"）;
printf（"输入你想要的插入类排序方法：
"）;
scanf（"%s",&x）;
printf（"\n"）;
if（x!
='a'&&x!
='b'&&x!
='c'）
{
printf（"输入有误！
请重新输入!
或!
!
"）;
scanf（"%c",&x）;}
returnx;}
charsele_mu（）
{charx;
printf（"\t\t\t\t\t\t┏━━━━━━━━━━━━━━━━┓\n"）;
printf（"\t\t\t\t\t\t┃━━━━选择类排序类排序━━━━┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃i.简单选择排序┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃k.堆排序┃\n"）;
printf（"\t\t\t\t\t\t┗━━━━━━━━━━━━━━━━┛\n"）;
printf（"输入你想要的选择类排序方法：
"）;
scanf（"%s",&x）;
printf（"\n"）;
if（x!
='i'&&x!
='k'）
{
printf（"输入有误！
请重新输入i或k"）;
scanf（"%s",&x）;
}
returnx;
}charchange_mu（）
{
charx;
printf（"\t\t\t\t\t\t┏━━━━━━━━━━━━━━━━┓\n"）;
printf（"\t\t\t\t\t\t┃━━━━━交换排序类排序━━━┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃!
.快速排序┃\n"）;
printf（"\t\t\t\t\t\t┃┃\n"）;
printf（"\t\t\t\t\t\t┃y.冒泡排序┃\n"）;
printf（"\t\t\t\t\t\t┗━━━━━━━━━━━━━━━━┛\n"）;
printf（"输入你想要的交换类排序方法：
"）;
scanf（"%s",&x）;
printf（"\n"）;
if（x!
='!
'&&x!
='y'）
{
printf（"输入有误！
请重新输入!
或y"）;
scanf（"%s",&x）;
}
returnx;
}
3、排序
#include
/************插入类排序******************/
voidinsetsort（intb[],intn）//直接插入排序
{inti,j,t;
for（i=1;i{
t=b[i];
for（j=i;j>0&&t{b[j]=b[j-1];}
b[j]=t;}}
voidsheelsort（intb[],intn）//希尔排序
{inti,j,delta,t;
for（delta=n/2;delta>=1;delta/=2）
{for（i=delta;i{t=b[i];
j=i-delta;
while（j>=0&&b[j]>t）{
b[j+delta]=b[j];
j-=delta;
}b[j+delta]=t;
}}}
voidbinarysotr（intb[],intn）//折半插入排序
{intlow,high,mid,i,j,t;
for（i=1;i{low=0;
high=i-1;
t=b[i];
while（low<=high）
{mid=（low+high）/2;
if（thigh=mid-1;}
for（j=i;j>low;j--）
b[j]=b[j-1];
b[low]=t;}}/************选择类排序******************/
voidselectsort（intb[],intn）//简单选择排序
{inti,j,k,t;
for（i=0;i{
k=i;//i被认为当前趟最小的元素的下标
for（j=i+1;j{if（b[k]>b[j]）
k=j;//找出当前趟最小元素下标记为k}
if（k!
=i）{
t=b[i];//当认为的和实际找到的最小元素的下标不等时，则交换
b[i]=b[k];
b[k]=t;}}}
voidadjustheap（intb[],ints,intn）//从编号s开始调整{
inti,j,t,flag;
i=s;
j=2*i+1;
t=b[i];
flag=0;
while（jflag）
{if（jj++;
if（t>b[j]）//如果根结点元素值大于孩子结点
flag=1;
else
{//逐层调整元素的位置
b[i]=b[j];
i=j;
j=2*i+1;
}}
b[i]=t;//将根结点存放到相应的位置
}voidheapsort（intb[],intn）//堆排序（完全二叉树）
{
inti,t;
for（i=n/2-1;i>=0;i--）//从n/2开始建立堆
adjustheap（b,i,n）;
for（i=n-1;i>0;i++）
{
t=b[0];
b[0]=b[i];
b[i]=t;
adjustheap（b,0,i）;//从根结点开始调整}}/************交换类排序******************/
voidbubblesort（intb[],intn）//冒泡排序
{inti,j,t;
for（i=0;i{
for（j=0;j{if（b[j]>b[j+1]）
{t=b[j];
b[j]=b[j+1];
b[j+1]=t;}}
printf（"第%d趟排序结果：
",i+1）;
for（j=0;j{if（（j+1）%50==0）
{
printf（"%4d\t",b[j]）;
printf（"\n"）;}
printf（"%4d\t",b[j]）;}
printf（"\n"）;}}
voidquicksort（intb[],intlow,inthigh）//快速排序
{inti,j,pivot;
i=low;
j=high;
pivot=b[low];
while（i{while（ij--;
if（i{b[i]=b[j];
i++;
}
while（ii++;
if（i{b[j]=b[i];
j--;}}
b[i]=pivot;
if（lowquicksort（b,low,i-1）;
if（iquicksort（b,j+1,high）;}/*归并排序*/
voidMerge（inta[],intlow,intmid,inthigh,intb[]）
{inti,j,k;
i=low;
j=mid+1;
k=low;
while（i<=mid&&j<=high）
{if（a[i]<=a[j]）
{b[k]=a[i];
i++;}
else{
b[k]=a[j];
j++;}
k++;}
while（i<=mid）
{b[k++]=a[i++];}
while（j<=high）
{b[k++]=a[j++];}}
voidMSort（inta[],intlow,inthigh,intc[]）
{c[low..high]中
intb[N],mid;
if（low==high）
c[low]=a[low];
else
{mid=（low+high）/2;
MSort（a,low,mid,b）;//递归的将a[low..high]归并为有序的b[low...high]
MSort（a,mid+1,high,b）;
Merge（b,low,mid,high,c）;//将a[low...mid]和c[mid...high]归并到c[low...high]}}
voidMergeSort（inta[],intn）//对数组中a元素进行归并排序
{MSort（a,0,n-1,a）;}
#include
#include"head.h"
/*基数排序*/
oidInitList（SList*L,DataTypea[],intn）//利用数组a的元
升级会员 