查找排序的应用实验.docx

查找排序的应用实验.docx

《查找排序的应用实验.docx》由会员分享，可在线阅读，更多相关《查找排序的应用实验.docx（14页珍藏版）》请在冰豆网上搜索。

查找排序的应用实验

淮海工学院计算机科学系

实验报告书

课程名：

《数据结构》

题目：

查找、排序的应用实验

班级：

学号：

姓名：

排序、查找的应用实验报告要求

1目的与要求:

1）查找、排序是日常数据处理过程中经常要进行的操作和运算，掌握其算法与应用对于提高学生数据处理能力和综合应用能力显得十分重要。

2）本次实验前，要求同学完整理解有关排序和查找的相关算法和基本思想以及种算法使用的数据存储结构；

3）利用C或C++语言独立完成本次实验内容或题目，程序具有良好的交互性（以菜单机制实现实验程序的交互运行）和实用性；

4）本次实验属于验收平分性质实验，希望同学们认真对待，并按时完成实验任务；

5）认真书写实验报告（包括程序清单及相关实验数据与完整运行结果），并按时提交。

2实验内容或题目

题目：

对记录序列（查找表）：

{55，13，23，72，109，67，2，78,13}分别实现如下操作：

1）顺序查找；

2）分别使用直接插入排序、冒泡排序、快速排序对原纪录序列进行排序（暂时人工排序）；

3）对排好序的纪录序列表进行折半查找；

4）利用原纪录序列建立一颗二叉排序树，并在其上实现特定关键字值结点的查找；

5）按照“除留余数法”哈希构造函数和线性探测再散列的冲突处理方法创建表长为m=11的哈希表（暂时不做，下次实验做）；

6）实现5）创建哈希表上的查找。

3实验步骤与源程序

#include

#include

#definemaxsize12

#defineTRUE1

#defineFALSE0

#defineNULL0

#definelistsize9

#definekeysize9

typedefintkeytype;

typedefstruct

{

intkey;

intflag;

}Elemtype;

typedefstructnode

{

intkey;

structnode*lchild,*rchild;

}bstnode,*bstree;

typedefstruct

{

intkey;

intnext;

}recordtype;

typedefstruct

{

recordtyper[listsize+1];

intlength;

}recordlist;

voidinitrecord（recordlist*l）

{

l->r[1].key=55;

l->r[2].key=13;

l->r[3].key=23;

l->r[4].key=72;

l->r[5].key=109;

l->r[6].key=67;

l->r[7].key=2;

l->r[8].key=78;

l->r[9].key=13;

}

//顺序查找

intseqsearch（recordlist*l,intk）

{

inti=l->length;

while（i>=1&&l->r[i].key!

=k）i--;

if（i>=1）

{

cout<<"存在该元素：

"<r[i].key<

cout<<"该元素所在位置：

"<

return（i）;

}

else

{

cout<<"不存在该元素！

"<

return（0）;

}

}

//直接插入排序

voidinssort（recordlist*l）

{

intj;

for（inti=2;i<=l->length;i++）

{

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

j=i-1;

while（l->r[0].keyr[j].key）

{

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

j=j-1;

}

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

}

for（intm=1;m<=l->length;m++）

cout<r[m].key<<"";

cout<

}

//冒泡排序

voidbubblesort（recordlist*l）

{

inti,j,x;

intchange=TRUE;

for（i=1;i<=l->length;++i）

{

for（j=1;j<=l->length-i;++j）

if（l->r[j].key>l->r[j+1].key）

{

x=l->r[j].key;

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

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

}

}

for（intm=1;m<=l->length;m++）

cout<r[m].key<<"";

cout<

}

//快速排序

intqkpass（recordlist*l,intleft,intright）

{

intx=l->r[left].key;

intlow=left;

inthigh=right;

while（low

{

while（lowr[high].key>=x）

high--;

if（low

{

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

low++;

}

while（lowr[high].key

low++;

if（low

{

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

high--;

}

}

l->r[low].key=x;

returnlow;

}

voidqksort（recordlist*l,intlow,inthigh）

{

intpos;

if（low

{

pos=qkpass（l,low,high）;

qksort（l,low,pos-1）;

qksort（l,pos+1,high）;

}

}

//折半查找

intbinsrch（recordlist*l,intk）

{

intlow=1,high=l->length,mid;

while（low<=high）

{

mid=（low+high）/2;

if（k==l->r[mid].key）

{

cout<<"存在该元素：

"<r[mid].key<

cout<<"该元素所在位置：

"<

return

（1）;

}

elseif（kr[mid].key）

high=mid-1;

else

low=mid+1;

}

cout<<"查找失败!

"<

return（0）;

}

//建立平衡二叉排序树

voidinsertbst（bstree*bst,intk）

{

bstrees;

if（*bst==NULL）

{

s=（bstnode*）malloc（sizeof（bstnode））;

s->key=k;

s->lchild=NULL;

s->rchild=NULL;

*bst=s;

}

elseif（k<（*bst）->key）

insertbst（&（（*bst）->lchild）,k）;

elseif（k>（*bst）->key）

insertbst（&（（*bst）->rchild）,k）;

}

voidcreatbstree（bstree*bst）

{

intk;

*bst=NULL;

cout<<"输入元素:

"<

cin>>k;

while（k!

=0）

{

insertbst（bst,k）;

cout<<"输入元素:

"<

cin>>k;

}

}

//二叉树查找

intsearchbst（bstreebst,intk）

{

if（!

bst）returnNULL;

elseif（bst->key==k）

{

cout<<"输出特定元素结点：

"<key<

return1;

}

else

if（kkey）

searchbst（bst->lchild,k）;

else

searchbst（bst->rchild,k）;

return0;

}

voidmain（）

{

intf=1,e,k,r,q;

chars;

recordlist*L;

bstree*B;

L=（recordlist*）malloc（sizeof（recordlist））;

B=（bstree*）malloc（sizeof（bstree））;

cout<<"输入所创顺序表的长度：

"<

cin>>r;

L->length=r;

cout<<"输入表的元素：

"<

for（inti=1;i<=L->length;i++）

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

while（f）

{

cout<<"顺序查找请输入A:

"<

cout<<"直接插入排序请输入B:

"<

cout<<"冒泡排序请输入C:

"<

cout<<"快速排序请输入D:

"<

cout<<"折半查找请输入E:

"<

cout<<"建立二叉排序树请输入F:

"<

cout<<"查找二叉树特定关键字请输入G:

"<

cout<<"输入操作序号：

"<

cin>>s;

switch（s）

{

case'A':

cout<<"进行顺序查找：

"<

cout<<"输入要查找的元素：

"<

cin>>k;

seqsearch（L,k）;

break;

case'B':

cout<<"进行直接插入排序：

"<

inssort（L）;

break;

case'C':

cout<<"还原原序列：

"<

initrecord（L）;

for（e=1;e<=L->length;e++）

cout<r[e].key<<"";

cout<

cout<<"进行冒泡排序：

"<

bubblesort（L）;

break;

case'D':

cout<<"还原原序列：

"<

initrecord（L）;

for（e=1;e<=L->length;e++）

cout<r[e].key<<"";

cout<

cout<<"快速排序：

"<

qksort（L,1,9）;

for（q=1;q<=L->length;q++）

cout<r[q].key<<"";

cout<

break;

case'E':

cout<<"进行折半查找:

"<

cout<<"输入要查找的元素：

"<

cin>>k;

binsrch（L,k）;

break;

case'F':

cout<<"建立二叉排序树,最后以00结束:

"<

creatbstree（B）;

break;

case'G':

cout<<"二叉排序树查找特定元素：

"<

cout<<"输入要查找元素：

"<

cin>>k;

searchbst（*B,k）;

break;

}

}

}

4测试数据与实验结果（可以抓图粘贴）

5结果分析与实验体会

这次试验不是很难，只要掌握了书本上的知识，基本上就可以独立完成，我现在越来越发现理解书本上的思想真的很重要，只有充分了解了书本上的思想，熟练地运用所学知识才会真正地掌握这门技术