数据结构实验8查找的算法Word格式.docx
《数据结构实验8查找的算法Word格式.docx》由会员分享，可在线阅读，更多相关《数据结构实验8查找的算法Word格式.docx（14页珍藏版）》请在冰豆网上搜索。
8.1
//实现顺序查找的算法
#include<
stdio.h>
#defineMAXL100//定义表中最多记录个数
typedefintKeyType;
typedefintInfoType;
typedefstruct
{
KeyTypekey;
//KeyType为关键字的数据类型
InfoTypedata;
//其他数据
}NodeType;
typedefNodeTypeSeqList[MAXL];
//顺序表类型
intSearch（SeqListR,intn,KeyTypek）//顺序查找算法
{
inti=0;
while（i<
n&
&
R[i].key!
=k）
{
printf（"
%d"
R[i].key）;
i++;
//从表头往后找
}
if（i>
=n）
return-1;
else
%d"
returni;
}
voidmain（）
SeqListR;
intn=10;
KeyTypek=5;
InfoTypea[]={3,6,2,10,1,8,5,7,4,9};
inti;
for（i=0;
i<
n;
i++）//建立顺序表
R[i].key=a[i];
printf（"
查找结果：
\n"
）;
if（（i=Search（R,n,k））!
=-1）
\n元素%d的位置是:
k,i）;
else
\n元素%d不在表中\n"
k）;
8.2
//实现折半查找算法
#defineMAXL100//定义表中最多记录个数
typedefcharInfoType[10];
//KeyType为关键字的数据类型
//顺序表类型
intBinSearch1（SeqListR,intn,KeyTypek）//非递归二分查找算法
intlow=0,high=n-1,mid,count=0;
while（low<
=high）
{
mid=（low+high）/2;
printf（"
第%d次查找:
在[%d,%d]中查找到元素R[%d]:
%d\n"
++count,low,high,mid,R[mid].key）;
if（R[mid].key==k）//查找成功返回
returnmid;
if（R[mid].key>
k）//继续在R[low..mid-1]中查找
high=mid-1;
else
low=mid+1;
//继续在R[mid+1..high]中查找
return-1;
intBinSearch2（SeqListR,KeyTypek,intlow,inthigh,intcount）//递归二分查找算法
intmid;
if（low<
elseif（R[mid].key>
BinSearch2（R,k,low,mid-1,count）;
BinSearch2（R,k,mid+1,high,count）;
elsereturn-1;
KeyTypek=9;
inta[]={1,2,3,4,5,6,7,8,9,10},i,n=10;
i++）//建立顺序表
用非递归方法:
if（（i=BinSearch1（R,n,k））!
元素%d的位置是%d\n"
元素%d不在表中\n"
用递归方法:
if（（i=BinSearch2（R,k,0,9,0））!
8.3
//实现二叉排序树的基本运算
#include<
//EOF,NULL
stdlib.h>
//atoi（）
iostream.h>
//cout,cin
typedefintStatus;
typedefstructBTNode
intkey;
structBTNode*lchild;
structBTNode*rchild;
}BTNode;
//定义二叉排序树插入结点的算法
intBSTInsert（BTNode*&
T,intk）
if（T==NULL）
T=（BTNode*）malloc（sizeof（BTNode））;
T->
lchild=T->
rchild=NULL;
key=k;
return1;
if（k==T->
key）
return0;
elseif（k<
T->
returnBSTInsert（T->
lchild,k）;
rchild,k）;
//定义二叉排序树的创建算法
BTNode*createBST（intk[],intn）
BTNode*T;
T=NULL;
for（inti=0;
=n-1;
i++）{
BSTInsert（T,k[i]）;
returnT;
//判断是否为二叉排序树
StatusJudge（BTNode*&
T）
return1;
elseif（（T>
lchild）&
（T<
rchild））
Judge（T->
lchild）;
rchild）;
elsereturn0;
//定义二叉排序树的查找算法
BTNode*BSTSearch（BTNode*&
returnNULL;
{printf（"
T->
key）;
if（T->
key==k）
returnBSTSearch（T->
inta[50]={4,9,0,1,8,6,3,5,2,7};
BTNode*bt=createBST（a,10）;
if（Judge（bt）==0）cout<
<
"
bt不是二叉排序树"
endl;
elsecout<
bt是二叉排序树"
cout<
查找关键字6的查找路径:
BTNode*t=BSTSearch（bt,6）;
8.4
//实现哈希表的相关运算
#defineMaxSize100//定义最大哈希表长度
#defineNULLKEY0//定义空关键字值
#defineDELKEY-1//定义被删关键字值
//关键字类型
typedefchar*InfoType;
//其他数据类型
typedefstruct
//关键字域
//其他数据域
intcount;
//探查次数域
}HashTable[MaxSize];
//哈希表类型
voidInsertHT（HashTableha,int*n,KeyTypek,intp）//将关键字k插入到哈希表中
inti,adr;
adr=k%p;
if（ha[adr].key==NULLKEY||ha[adr].key==DELKEY）//x[j]可以直接放在哈希表中
ha[adr].key=k;
ha[adr].count=1;
else//发生冲突时采用线性探查法解决冲突
i=1;
//i记录x[j]发生冲突的次数
do
{
adr=（adr+1）%p;
i++;
}while（ha[adr].key!
=NULLKEY&
ha[adr].key!
=DELKEY）;
ha[adr].count=i;
n++;
voidCreateHT（HashTableha,KeyTypex[],intn,intm,intp）//创建哈希表
inti,n1=0;
m;
i++）//哈希表置初值
ha[i].key=NULLKEY;
ha[i].count=0;
i++）
InsertHT（ha,&
n1,x[i],p）;
intSearchHT（HashTableha,intp,KeyTypek）//在哈希表中查找关键字k
inti=0,adr;
while（ha[adr].key!
=k）
//采用线性探查法找下一个地址
adr=（adr+1）%p;
if（ha[adr].key==k）//查找成功
returnadr;
else//查找失败
intDeleteHT（HashTableha,intp,intk,int*n）//删除哈希表中关键字k
intadr;
adr=SearchHT（ha,p,k）;
if（adr!
=-1）//在哈希表中找到该关键字
ha[adr].key=DELKEY;
n--;
//哈希表长度减1
else//在哈希表中未找到该关键字
return0;
voidDispHT（HashTableha,intn,intm）//输出哈希表
floatavg=0;
哈希表地址:
\t"
i++）
%3d"
i）;
\n"
哈希表关键字:
if（ha[i].key==NULLKEY||ha[i].key==DELKEY）
printf（"
"
//输出3个空格
ha[i].key）;
搜索次数:
ha[i].count）;
if（ha[i].key!
ha[i].key!
=DELKEY）
avg=avg+ha[i].count;
avg=avg/n;
平均搜索长度ASL（%d）=%g\n"
n,avg）;
intx[]={16,74,60,43,54,90,46,31,29,88,77};
intn=11,m=13,p=13,i,k=29;
HashTableha;
CreateHT（ha,x,n,m,p）;
DispHT（ha,n,m）;
查找关键字29:
i=SearchHT（ha,p,k）;
if（i!
ha[%d].key=%d\n"
i,k）;
未找到%d\n"
k=77;
删除关键字%d\n"
DeleteHT（ha,p,k,&
n）;
DispHT（ha,n,m）;
插入关键字%d\n"
InsertHT（ha,&
n,k,p）;
四，实验小结
1、通过本次实验，加深了我对查找表的认识。
2、有序表的查找之折半查找：
前提必须是有序表，性能只有在均匀分布的时候才是最优的。
3、二叉排序树查找：
通过一系列的查找和插入过程形成的树。
之所以叫做排序树，因为按照中序遍历可得一个有序的序列。
升级会员 