东华理工大学数据结构课程设计

数据结构课程设计

论文题目：基于线性表下的查找与排序

姓名：赖德发

学院：理学院

专业：信息与计算科学

班级：1123202

学号：201120320202

2014年1月17日

一、实验环境

（1）硬件：学生每人一台计算机。

（2）软件：Windows操作系统，Visual C++6.0。

二、实验内容

基于线性表下的查找与排序。

三、实验原理

1.基于线性表的查找法概述

集合结构是数据对象之间关系松散的一种数据结构，对其进行查找是根据给定的关键字，在特定的列表中确定一个其关键字与给定值相同的数据元素，并返回该数据元素在列表中的位置。查找的方法分为比较式查找法和计算式查找法，其中比较式查找法可分为基于线性表的查找法和基于树的查找法；而计算式查找法也称为Hash(哈希)查找法。基于线性表的查找法是将集合的数据对象组织成为线性表形式进行查找，即用给定的关键字与线性表中各元素的关键字逐个比较，直到成功或失败。线性表的存储结构通常是顺序存储结构，也可使用链式存储结构。

查找时可在表的一端设置一个“监视哨”，存放要查找元素的关键字，从表的另一端开始查找，若在“监视哨”找到要查找元素的关键字，返回失败信息，否则返回关键字的位序。基于线性表的查找技术有着非常广泛的应用。

2.基于线性表的排序法概述

排序是计算机程序设计中的一种重要操作，在数值计算或数据处理过程中，都会直接或间接用到数据的排序问题。排序的功能是将一个数据元素（或称记录）的无序序列，按数据元素的关键字大小排列成一个递增或递减有序的记录序列。

由于待排序的记录数量不同，使得排序过程中涉及的存储器也不同，因此可将排序方法分为内排序和外排序。内排序包括插入、交换、选择和归并等几类排序。

2.1基于插入类的排序概述

插入类排序的基本思想是假定记录序列中前面的一部分记录已经有序，把后面的一个记录插入已排序的有序子序列中去，使得插入这个记录后得到的依然是有序序列，从而逐步扩大有序的子序列的长度，直到所有记录都有序为止。直接插入排序是采用顺序查找法来确定记录的插入位置。折半插入排序是采用折半查找法来确定记录的插入位置。希尔排序是对待排序记录序列先做宏观直接插入排序调整，再做微观直接插入排序调整，故称缩小增量排序排序。

2.2基于交换类的排序概述

交换排序的基本思想是两两比较待排序记录的关键字，当两个记录的次序相反时进行交换，直到没有反序的记录为止。基于交换类的排序有冒泡排序和快速排序。

冒泡排序是比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

2.3基于选择类的排序概述

选择排序的基本思想是从每一趟待排序数据中选取一个关键字最小的记录，并置于适当的位置上。即第一趟从n个记录中选取关键字最小的记录，第二趟从剩下的n-1个记录中选取关键字最小的记录，直到整个序列的记录选完，由选取记录的顺序便可得到关键字有序的序列。堆排序的基本思想是通过类似于淘汰赛的想法，让序列中的关键字两两相比，不断淘汰较大者，最终选出关键字最小的记录。

四、系统测试

4.1基于线性表的查找源代码

#include

#include

#define LIST_SIZE 100

//定义顺序表的最大长度

typedef int keyType ;

//定义关键字类型为整形

typedef struct

{

keyType key ;

//关键字项

}

RecordType ;

//记录类型

typedef struct

{

RecordType r[LIST_SIZE+1];

//r[0]用作监视哨

int length ;

//定义顺序表长度

}

RecordList ;

//顺序表类型

/*函数申明*/

void CreatList(RecordList*L);

int SeqSearch(RecordList*l,keyType k); int BinSrch(RecordList*l,keyType k); void Display(RecordList*L);

void shunxu();

void zheban();

void Menu();

//主函数

int main()

{

int i ;

Menu();

printf("请选择:\n");

scanf("%d",&i);

switch(i)

{

case 1 :

{

shunxu();

break ;

}

case 2 :

{

zheban();

break ;

}

case 3 :

exit(1);

default :

{

printf("输入命令错误，请重新输入!\n");

break ;

}

Menu();

printf("请选择:\n");

scanf("%d",&i);

}

return 0 ;

}

//创建线性表

void CreatList(RecordList*L)

{

int i ;

printf("请输入数据元素的个数:");

scanf("%d",&L->length);

printf("请输入数据元素:\n");

for(i=1;i<=L->length;i++)

scanf("%d",&L->r[i]);

}

/*有哨兵的顺序查找*/

int SeqSearch(RecordList*l,keyType k)

{

int i ;

l->r[0].key=k ;

i=l->length ;

while(l->r[i].key!=k)

i--;

return i ;

}

/*折半查找*/

int BinSrch(RecordList*l,keyType k)

{

int low,high,mid ;

low=1 ;

high=l->length ;

while(low<=high)

{

mid=(low+high)/2 ;

if(k==l->r[mid].key)

return mid ;

else if(kr[mid].key)

high=mid-1 ;

else

low=mid+1 ;

}

return 0 ;

}

/*折半查找结果*/

void zheban()

{

int key ;

RecordList l ;

printf("折半查找如下:\n");

CreatList(&l);

Display(&l);

printf("\n请输入关键字数据:\n");

scanf("%d",&key);

if(BinSrch(&l,key))

printf("关键字数据的位置是:%d\n",BinSrch(&l,key));

else

printf("不存在这样的关键字!\n");

}

/*顺序查找结果*/

void shunxu()

{

int key ;

RecordList l ;

printf("顺序查找如下:\n");

CreatList(&l);

Display(&l);

printf("\n请输入关键字数据:\n");

scanf("%d",&key);

if(SeqSearch(&l,key))

printf("关键字数据的位置是:%d\n",SeqSearch(&l,key));

else

printf("不存在这样的关键字!\n");

}

//输出线性表

void Display(RecordList*L)

{

int i ;

printf("数据集合输出:\n");

printf("序号\t\t");

for(i=1;i<=L->length;i++)

printf("%d\t",i);

printf("\n");

printf("数据元素\t");

for(i=1;i<=L->length;i++)

printf("%d\t",L->r[i]);

printf("\n");

}

//程序菜单

void Menu()

{

printf("/********************************基于线性表的查找******************************/");

printf("/* 1:顺序查找*/");

printf("/* 2:折半查找*/");

printf("/* 3:退出*/");

printf("/******************************************************************************/") ;

}

测试结果如下：

4.2基于线性表的排序源代码

#include

#include

#define MAXSIZE 100//定义顺序表的最大长度typedef int keyType;//定义关键字类型为整形typedef struct

{

keyType key;//关键字项

}RedType;//记录类型

typedef struct

{

RedType r[MAXSIZE+1];//r[0]用作监视哨

int length;//定义顺序表长度

}SqList;//顺序表类型

//函数申明

void CreateSqList(SqList *L);

void InsertSort(SqList *L);

void BInsertSort(SqList *L);

void ShellInsert(SqList *L,int dk);

void ShellSort(SqList *L,int dlta[],int t);

void BubbleSort(SqList *L);

int Partition(SqList *L,int low,int high);

void QSort(SqList *L,int s,int t);

void QuickSort(SqList *L);

void SelectSort(SqList *L);

void HeapAdjust(SqList *L,int s,int t);

void HeapSort(SqList *L);

void Display(SqList *L);

void Menu();

int main() //主函数

{

int i;

SqList l;

int dlta[3]={5,3,1};//希尔排序的增量

Menu();

printf("请选择:");

scanf("%d",&i);

switch(i)

{

case 1:

{

CreateSqList(&l);

Display(&l);

InsertSort(&l);

printf("直接插入排序输出:\n");

Display(&l);

break;

}

case 2:

{

CreateSqList(&l);

Display(&l);

BInsertSort(&l);

printf("折半插入排序输出:\n");

Display(&l);

break;

}

case 3:

{

CreateSqList(&l);

Display(&l);

ShellSort(&l,dlta,3);

printf("希尔排序输出:\n");

Display(&l);

break;

}

case 4:

{

CreateSqList(&l);

Display(&l);

BubbleSort(&l);

printf("冒泡排序输出:\n");

Display(&l);

break;

}

case 5:

{

CreateSqList(&l);

Display(&l);

QuickSort(&l);

printf("快速排序输出:\n");

Display(&l);

break;

}

case 6:

{

CreateSqList(&l);

Display(&l);

SelectSort(&l);

printf("简单选择排序输出:\n");

Display(&l);

break;

}

case 7:

{

CreateSqList(&l);

Display(&l);

HeapSort(&l);

printf("堆排序输出:\n");

Display(&l);

break;

}

case 0:

exit(1);

default:

{

printf("输入命令错误，请重新输入!\n");

break;

}

Menu();

printf("请选择:\n");

scanf("%d",&i);

}

return 0;

}

void CreateSqList(SqList *L)//创建线性表

{

int i;

printf("请输入数据元素的个数:");

scanf("%d",&L->length);

printf("请输入数据元素:\n");

for(i=1;i<=L->length;i++)

scanf("%d",&L->r[i]);

}

void InsertSort(SqList *L)//直接插入排序

{

int i,j;

for(i=2;i<=L->length;++i)

if(L->r[i].keyr[i-1].key)

{

L->r[0]=L->r[i];

L->r[i]=L->r[i-1];

for(j=i-2;L->r[0].keyr[j].key;--j)

L->r[j+1]=L->r[j];

L->r[j+1]=L->r[0];

}

}

void BInsertSort(SqList *L)//折半插入排序

{

int i,j,low,high,m;

for(i=2;i<=L->length;++i)

{

L->r[0]=L->r[i];

low=1;

high=i-1;

while(low<=high)

{

m=(low+high)/2;

if(L->r[0].keyr[m].key)

high=m-1;

else

low=m+1;

}

for(j=i-1;j>=high+1;--j)

L->r[j+1]=L->r[j];

L->r[high+1]=L->r[0];

}

}

void ShellInsert(SqList *L,int dk) //一趟希尔排序{

int i,j;

for(i=dk+1;ilength;++i)

if(L->r[i].keyr[i-dk].key)

{

L->r[0]=L->r[j];

for(j=i-dk;j>0&&(L->r[0].keyr[j].key);j-=dk) L->r[j+dk]=L->r[j];

L->r[j+dk]=L->r[0];

}

}

void ShellSort(SqList *L,int dlta[],int t)//希尔排序

{

int k;

for(k=0;k

ShellInsert(L,dlta[k]);

}

void BubbleSort(SqList *L)//冒泡排序法

{

int i=L->length,j,temp;

int lastExchangeIndex;

while(i>1)

{

lastExchangeIndex=1;

for(j=1;j

if(L->r[j+1].keyr[j].key)

{

temp=L->r[j+1].key;

L->r[j+1].key=L->r[j].key;

L->r[j].key=temp;

lastExchangeIndex=j;

}

i=lastExchangeIndex;

}

}

int Partition(SqList *L,int low,int high)//一趟快速排序寻找枢轴{

int key;

key=L->r[low].key;

while(low

{

while(lowr[high].key>=key)

--high;

L->r[low].key=L->r[high].key;

while(lowr[low].key<=key)

++low;

L->r[high].key=L->r[low].key;

}

L->r[low].key=key;

return low;

}

void QSort(SqList *L,int s,int t)//对区间[s,t]进行快速排序{

int pivotloc=Partition(L,s,t);

if(t-s<=1)

return;

QSort(L,s,pivotloc-1);

QSort(L,pivotloc+1,t);

}

void QuickSort(SqList *L) //对顺序表进行快速排序{

QSort(L,1,L->length);

}

void SelectSort(SqList *L) //简单选择排序

{

int i,j,temp,t;

for(i=1;ilength;i++)

{

for(j=i+1,t=i;j<=L->length;j++)

{

if(L->r[t].key>L->r[j].key)

t=j;

}

if(t!=i)

{

temp=L->r[t].key;

L->r[t].key=L->r[i].key;

L->r[i].key=temp;

}

}

}

void HeapAdjust(SqList *L,int s,int t) //堆的赛选{

int j,key;

key=L->r[s].key;

for(j=2*s;j<=t;j*=2)

{

if(jr[j].keyr[j+1].key)

++j;

if(key>=L->r[j].key)

break;

L->r[s].key=L->r[j].key;

s=j;

}

L->r[s].key=key;

}

void HeapSort(SqList *L) //对顺序表进行堆排序{

int key,i;

for(i=L->length/2;i>0;i--)

HeapAdjust(L,i,L->length);

for(i=L->length;i>1;--i)

{

key=L->r[1].key;

L->r[1].key=L->r[i].key;

L->r[i].key=key;

HeapAdjust(L,1,i-1);

}

}

void Display(SqList *L) //输出线性表

{

int i;

printf("数据集合输出:\n");

printf("序号\t\t");

for(i=1;i<=L->length;i++)

printf("%d\t",i);

printf("\n");

printf("数据元素\t");

for(i=1;i<=L->length;i++)

printf("%d\t",L->r[i]);

printf("\n");

}

void Menu() //程序菜单

{

printf("/**********************************基于线性表的各种排序************************/");

printf(" 1:直接插入排序\n");

printf(" 2:折半插入排序\n");

printf(" 3:希尔排序\n");

printf(" 4:冒泡排序\n");

printf(" 5:快速排序\n");

printf(" 6:简单选择排序\n");

printf(" 7:堆排序\n");

printf(" 0:退出\n");

printf("/**************************************************************************** **/\n");

}

测试结果如下：

4.3测试评价

优点：此次做的基于线性表下的查找和排序系统，采用顺序存储结构，融合了各种查找和排序的算法，简单方便，执行效率高。

不足与改进:此次课程设计由于时间有限，查找法只做了基于线性表下的查找法，基于树的查找和计算式查找(Hash法查找)没有做，课外空余时间可以再去做做。对于排序也还有归并排序没有做，留到课外再完善吧。

五、实习体会与总结

经过这次数据结构的课程设计，首先使我对数据结构这门课更感兴趣，也对编程和这门课程有了更深入的体会和认知，数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。这门课对于计算机类的专业确实非常重要，起到举足轻重的作用，如果想干计算机这一行，那这门课一定要更深入的学习才行。其次，通过这次课程设计，让我对编程方面有了极大的进步，自己的程序调试能力也有了很大的提升，增加了自信。最后通过这次的课程设计，更是让我深刻认识到自己在学习中的不足，同时也找到了克服这些不足的方法，这也是一笔很大的资源。在以后的时间中，我们应该利用更多的时间去上机实验，加强自学的能力，多编写程序，相信不久后我们的编程能力都会有很大的提高，能设计出更多的更有创新的作品。

总而言之，在这次的课程设计中不仅检验了我所学习的知识，也培养了我如何去把握一件事情，如何去做一件事情，又如何完成一件事情的方法和技巧。在设计过程中，和同学们相互探讨，相互学习，相互监督。我学会了运筹帷幄，学会了宽容，学会了理解，也学会了做人与处世，这次课程设计对我来说真的受益良多。

六、参考文献

1.数据结构试验教程(C语言版），王青海编著，中国铁道部出版社，2012年9月。

2.数据结构用C语言描述，耿国华主编，高等教育出版社，2013年4月。