东华理工大学数据结构课程设计文档格式.docx
《东华理工大学数据结构课程设计文档格式.docx》由会员分享，可在线阅读，更多相关《东华理工大学数据结构课程设计文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
基于交换类的排序有冒泡排序和快速排序。
冒泡排序是比较相邻的元素。
如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。
在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
快速排序是对冒泡排序的一种改进。
它的基本思想是：
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
2.3基于选择类的排序概述
选择排序的基本思想是从每一趟待排序数据中选取一个关键字最小的记录，并置于适当的位置上。
即第一趟从n个记录中选取关键字最小的记录，第二趟从剩下的n-1个记录中选取关键字最小的记录，直到整个序列的记录选完，由选取记录的顺序便可得到关键字有序的序列。
堆排序的基本思想是通过类似于淘汰赛的想法，让序列中的关键字两两相比，不断淘汰较大者，最终选出关键字最小的记录。
4、系统测试
4.1基于线性表的查找源代码
#include<
stdio.h>
process.h>
#defineLIST_SIZE100
//定义顺序表的最大长度
typedefintkeyType;
//定义关键字类型为整形
typedefstruct
{
keyTypekey;
//关键字项
}
RecordType;
//记录类型
RecordTyper[LIST_SIZE+1];
//r[0]用作监视哨
intlength;
//定义顺序表长度
RecordList;
//顺序表类型
/*函数申明*/
voidCreatList（RecordList*L）;
intSeqSearch（RecordList*l,keyTypek）;
intBinSrch（RecordList*l,keyTypek）;
voidDisplay（RecordList*L）;
voidshunxu（）;
voidzheban（）;
voidMenu（）;
//主函数
intmain（）
inti;
Menu（）;
printf（"
请选择:
\n"
）;
scanf（"
%d"
&
i）;
switch（i）
{
case1:
shunxu（）;
break;
}
case2:
zheban（）;
case3:
exit
（1）;
default:
输入命令错误，请重新输入!
return0;
//创建线性表
voidCreatList（RecordList*L）
请输入数据元素的个数:
"
L->
length）;
请输入数据元素:
for（i=1;
i<
=L->
length;
i++）
r[i]）;
/*有哨兵的顺序查找*/
intSeqSearch（RecordList*l,keyTypek）
l->
r[0].key=k;
i=l->
length;
while（l->
r[i].key!
=k）
i--;
returni;
/*折半查找*/
intBinSrch（RecordList*l,keyTypek）
intlow,high,mid;
low=1;
high=l->
while（low<
=high）
mid=（low+high）/2;
if（k==l->
r[mid].key）
returnmid;
elseif（k<
l->
high=mid-1;
else
low=mid+1;
/*折半查找结果*/
voidzheban（）
intkey;
RecordListl;
折半查找如下:
CreatList（&
l）;
Display（&
\n请输入关键字数据:
key）;
if（BinSrch（&
l,key））
关键字数据的位置是:
%d\n"
BinSrch（&
l,key））;
不存在这样的关键字!
/*顺序查找结果*/
voidshunxu（）
顺序查找如下:
if（SeqSearch（&
SeqSearch（&
//输出线性表
voidDisplay（RecordList*L）
数据集合输出:
序号\t\t"
%d\t"
i）;
数据元素\t"
L->
//程序菜单
voidMenu（）
/********************************基于线性表的查找******************************/"
/*1:
顺序查找*/"
/*2:
折半查找*/"
/*3:
退出*/"
/******************************************************************************/"
测试结果如下：
4.2基于线性表的排序源代码
#defineMAXSIZE100//定义顺序表的最大长度
typedefintkeyType;
typedefstruct
keyTypekey;
//关键字项
}RedType;
RedTyper[MAXSIZE+1];
//r[0]用作监视哨
intlength;
//定义顺序表长度
}SqList;
//函数申明
voidCreateSqList（SqList*L）;
voidInsertSort（SqList*L）;
voidBInsertSort（SqList*L）;
voidShellInsert（SqList*L,intdk）;
voidShellSort（SqList*L,intdlta[],intt）;
voidBubbleSort（SqList*L）;
intPartition（SqList*L,intlow,inthigh）;
voidQSort（SqList*L,ints,intt）;
voidQuickSort（SqList*L）;
voidSelectSort（SqList*L）;
voidHeapAdjust（SqList*L,ints,intt）;
voidHeapSort（SqList*L）;
voidDisplay（SqList*L）;
intmain（）//主函数
inti;
SqListl;
intdlta[3]={5,3,1};
//希尔排序的增量
Menu（）;
printf（"
scanf（"
switch（i）
{
case1:
{
CreateSqList（&
Display（&
InsertSort（&
printf（"
直接插入排序输出:
break;
}
case2:
BInsertSort（&
折半插入排序输出:
case3:
ShellSort（&
l,dlta,3）;
希尔排序输出:
case4:
{
BubbleSort（&
冒泡排序输出:
case5:
QuickSort（&
快速排序输出:
case6:
SelectSort（&
简单选择排序输出:
case7:
HeapSort（&
堆排序输出:
case0:
exit
（1）;
default:
{
printf（"
break;
}
Menu（）;
printf（"
scanf（"
}
return0;
voidCreateSqList（SqList*L）//创建线性表
inti;
voidInsertSort（SqList*L）//直接插入排序
inti,j;
for（i=2;
++i）
if（L->
r[i].key<
r[i-1].key）
L->
r[0]=L->
r[i];
r[i]=L->
r[i-1];
for（j=i-2;
r[0].key<
r[j].key;
--j）
r[j+1]=L->
r[j];
r[0];
voidBInsertSort（SqList*L）//折半插入排序
inti,j,low,high,m;
low=1;
high=i-1;
m=（low+high）/2;
r[m].key）
high=m-1;
else
low=m+1;
for（j=i-1;
j>
=high+1;
r[high+1]=L->
voidShellInsert（SqList*L,intdk）//一趟希尔排序
for（i=dk+1;
r[i-dk].key）
for（j=i-dk;
0&
&
（L->
r[j].key）;
j-=dk）
r[j+dk]=L->
voidShellSort（SqList*L,intdlta[],intt）//希尔排序
intk;
for（k=0;
k<
t;
k++）
ShellInsert（L,dlta[k]）;
voidBubbleSort（SqList*L）//冒泡排序法
inti=L->
length,j,temp;
intlastExchangeIndex;
while（i>
1）
lastExchangeIndex=1;
for（j=1;
j<
i;
j++）
r[j+1].key<
r[j].key）
temp=L->
r[j+1].key;
r[j+1].key=L->
r[j].key=temp;
lastExchangeIndex=j;
i=lastExchangeIndex;
intPartition（SqList*L,intlow,inthigh）//一趟快速排序寻找枢轴
intkey;
key=L->
r[low].key;
high）
high&
r[high].key>
=key）
--high;
r[low].key=L->
r[high].key;
r[low].key<
++low;
r[high].key=L->
r[low].key=key;
returnlow;
voidQSort（SqList*L,ints,intt）//对区间[s,t]进行快速排序
intpivotloc=Partition（L,s,t）;
if（t-s<
=1）
return;
QSort（L,s,pivotloc-1）;
QSort（L,pivotloc+1,t）;
voidQuickSort（SqList*L）//对顺序表进行快速排序
QSort（L,1,L->
voidSelectSort（SqList*L）//简单选择排序
inti,j,temp,t;
for（j=i+1,t=i;
if（L->
r[t].key>
t=j;
if（t!
=i）
temp=L->
r[t].key;
L->
r[t].key=L->
r[i].key;
r[i].key=temp;
voidHeapAdjust（SqList*L,ints,intt）//堆的赛选
intj,key;
r[s].key;
for（j=2*s;
=t;
j*=2）
if（j<
t&
r[j].key<
r[j+1].key）
++j;
if（key>
break;
L->
r[s].key=L->
s=j;
r[s].key=key;
voidHeapSort（SqList*L）//对顺序表进行堆排序
intkey,i;
for（i=L->
length/2;
i>
0;
i--）
HeapAdjust（L,i,L->
1;
--i）
key=L->
r[1].key;
r[1].key=L->
r[i].key=key;
HeapAdjust（L,1,i-1）;
voidDisplay（SqList*L）//输出线性表
voidMenu（）//程序菜单
/**********************************基于线性表的各种排序************************/"
1:
直接插入排序\n"
2:
折半插入排序\n"
3:
希尔排序\n"
4:
冒泡排序\n"
5:
快速排序\n"
6:
简单选择排序\n"
7:
堆排序\n"
0:
退出\n"
/******************************************************************************/\n"
4.3测试评价
优点：
此次做的基于线性表下的查找和排序系统，采用顺序存储结构，融合了各种查找和排序的算法，简单方便，执行效率高。
不足与改进:
此次课程设计由于时间有限，查找法只做了基于线性表下的查找法，基于树的查找和计算式查找（Hash法查找）没有做，课外空余时间可以再去做做。
对于排序也还有归并排序没有做，留到课外再完善吧。
五、实习体会与总结
经过这次数据结构的课程设计，首先使我对数据结构这门课更感兴趣，也对编程和这门课程有了更深入的体会和认知，数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。
这门课对于计算机类的专业确实非常重要，起到举足轻重的作用，如果想干计算机这一行，那这门课一定要更深入的学习才行。
其次，通过这次课程设计，让我对编程方面有了极大的进步，自己的程序调试能力也有了很大的提升，增加了自信。
最后通过这次的课程设计，更是让我深刻认识到自己在学习中的不足，同时也找到了
升级会员 