查找算法的实现 数据结构实验

实验报告May 28 2015

姓名：陈斌学号：E11314079 专业：13计算机科学与技术数据结构第五次实验

学号E11314079专业计算机科学与技术姓名陈斌

实验日期2015.05.28教师签字成绩

实验报告

【实验名称】查找算法的实现

【实验目的】

掌握顺序查找、二分查找、二叉排序树和哈希表的相关算法和运算并编程实现【实验内容】

1.实现顺序查找的算法

编写一个程序，输出在顺序表

{ 12 , 3 , 4 , 10 , 23 , 1 , 9 , 18 }

中采用顺序方法分别查找关键字23 和20的过程。

要求：

(1)程序能够输出查找过程中参与比较的全部关键字；

(2)查找结果的表现形式：若查找成功，则输出关键字的位置，否则输出“找

不到该关键字！”的信息。

源代码：

head.h:

#include

#include

#include //malloc( )

#include // INT ,MAX

#include //EOF,NULL

#include //atoi( )

#include //eof( )

#include //floor( ),ceil( ),abs( )

#include //exit( )

#include //cout,cin

//函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

//OVERFLOW 在math.h 中已定义为3

typedef int Status;

typedef int Boolean; // 布尔类型

main.cpp:

#include "head.h"

typedef int KeyType;

#define N 8 /* 数据元素个数*/

typedef struct /* 数据元素类型*/

{

KeyType key; /* 关键字域*/

int others; /* 其它部分*/

}ElemType;

ElemType r[N]={{12,1},{3,2},{4,3},{10,4},{23,5},{1,6},{9,7},{18,8}};

typedef struct

{

ElemType *elem; //数据元素存储空间基址，建表时按实际长度分配，0号单元留空int length; /* 表长度*/

}SSTable;

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

int Search_Seq(SSTable &ST,KeyType key)

{ /* 在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为*/ /* 该元素在表中的位置，否则为0。算法9.1 */

ST.elem[0].key=key; /* 哨兵*/

cout<<"参与比较的关键字为:";

for(int i=ST.length;!EQ(ST.elem[i].key,key);--i) /* 从后往前找*/

cout<

cout<

return i; /* 找不到时，i为0 */

}

Status Creat_Seq(SSTable &ST,int n)

{ //操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r) ST.elem=(ElemType *)calloc(n+1,sizeof(ElemType)); /* 动态生成n个数据元素空间(0号单元不用) */

if(!ST.elem)

return ERROR;

for(int i=1;i<=n;i++)

*(ST.elem+i)=r[i-1]; /* 将全局数组r的值依次赋给ST */

ST.length=n;

return OK;

}

Status Destroy(SSTable &ST)

{ /* 初始条件: 静态查找表ST存在。操作结果: 销毁表ST */

free(ST.elem);

ST.elem=NULL;

ST.length=0;

return OK;

}

void Display(SSTable ST)

{

cout<<"待查找的顺序表为:\n";

for(int i=1;i<=ST.length;i++)

cout<<"("<

cout<

}

void main()

{

SSTable st;

Creat_Seq(st,8);

KeyType s;

Display(st);

for(int j=1;j<=2;j++)

{

cout<<"请输入待查找值的关键字:";

cin>>s;

int i=Search_Seq(st,s);

if(i)

cout<<"关键字"<

else

cout<<"找不到该关键字!"<

}

Destroy(st);

}

运行结果：

2.实现二分查找的算法

编写一个程序，输出在有序顺序表

{ 2，8，12，20，26，30，43，67}

中采用二分查找法查找关键字12 和38的过程。要求：

(1)程序能够输出查找过程中参与比较的全部关键字；

(2)查找结果的表现形式：若查找成功，则输出关键字的位置，否则输出“找

不到该关键字！”的信息。

源代码：

head.h:

#include

#include

#include //malloc( )

#include // INT ,MAX

#include //EOF,NULL

#include //atoi( )

#include //eof( )

#include //floor( ),ceil( ),abs( )

#include //exit( )

#include //cout,cin

//函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

//OVERFLOW 在math.h 中已定义为3

typedef int Status;

typedef int Boolean; // 布尔类型

main.cpp:

#include "head.h"

typedef int KeyType;

#define N 8 /* 数据元素个数*/

typedef struct /* 数据元素类型*/

{

KeyType key; /* 关键字域*/

int others; /* 其它部分*/

}ElemType;

ElemType r[N]={{2,1},{8,2},{12,3},{20,4},{26,5},{30,6},{43,7},{67,8}};

typedef struct

{

ElemType *elem; //数据元素存储空间基址，建表时按实际长度分配，0号单元留空int length; /* 表长度*/

}SSTable;

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

int Search_Bin(SSTable &ST,KeyType key)

{ /* 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则函数值为*/ /* 该元素在表中的位置，否则为0。算法9.2 */

int low=1,high=ST.length; //置区间初值

cout<<"参与比较的关键字为:";

while(low<=high)

{

int mid=(low+high)/2;

cout<

if(EQ(key,ST.elem[mid].key))//找到待查元素

return mid;

else if(LT(key,ST.elem[mid].key))//继续在前半区间进行查找

high=mid-1;

else //继续在后半区间进行查找

low=mid+1;

}

cout<

return 0; //有序表中不存在待查元素

}

Status Creat_Seq(SSTable &ST,int n)

{ //操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自全局数组r) ST.elem=(ElemType *)calloc(n+1,sizeof(ElemType)); /* 动态生成n个数据元素空间(0号单元不用) */

if(!ST.elem)

return ERROR;

for(int i=1;i<=n;i++)

*(ST.elem+i)=r[i-1]; /* 将全局数组r的值依次赋给ST */

ST.length=n;

return OK;

}

Status Destroy(SSTable &ST)

{ /* 初始条件: 静态查找表ST存在。操作结果: 销毁表ST */

free(ST.elem);

ST.elem=NULL;

ST.length=0;

return OK;

}

void Display(SSTable ST)

{

cout<<"待查找的有序表为:\n";

for(int i=1;i<=ST.length;i++)

cout<<"("<

cout<

}

void main()

{

SSTable st;

Creat_Seq(st,8);

KeyType s;

Display(st);

for(int j=1;j<=2;j++)

{

cout<<"请输入待查找值的关键字:";

cin>>s;

int i=Search_Bin(st,s);

if(i)

cout<<"\n关键字"<

else

cout<<"找不到该关键字!"<

}

Destroy(st);

}

运行结果：

折半查找的判定树:

3. 实现二叉排序树的基本运算

编写一个程序实现二叉排序树的基本运算，并在此基础上完成如下功能：

(1) 由{4,19,10,1, 28,6, 13, 5, 12, 7}创建一个二叉排序树bt ；

(2) 判断bt 是否为一棵二叉排序树（提示：写一个函数，在遍历过程中检查是否符合二叉排序树定义）；

(3) 采用非递归方法查找关键字为6的结点，并输出查找过程中参与比较的全部关键字。

20 8 30 43

67 26 12 2

源代码：

head.h:

#include

#include

#include //malloc( )

#include // INT ,MAX

#include //EOF,NULL

#include //atoi( )

#include //eof( )

#include //floor( ),ceil( ),abs( )

#include //exit( )

#include //cout,cin

//函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

//OVERFLOW 在math.h 中已定义为3

typedef int Status;

typedef int Boolean; // 布尔类型

main.cpp:

#include"head.h"

typedef int KeyType;

#define N 10

typedef struct /* 数据元素类型*/

{

KeyType key; /* 关键字域*/

}ElemType;

ElemType r[N]={4,19,10,1,28,6,13,5,12,7};

typedef ElemType TElemType;

typedef struct BiTNode

{

TElemType data;

struct BiTNode *lchild,*rchild; /* 左右孩子指针*/ }BiTNode,*BiTree;

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)<(b))

#define LQ(a,b) ((a)<=(b))

Status InitDSTable(BiTree &DT)

{ /* 操作结果: 构造一个空的动态查找表DT */

DT=NULL;

return OK;

}

void DestroyDSTable(BiTree DT)

{ /* 初始条件: 动态查找表DT存在。操作结果: 销毁动态查找表DT */

if(DT) /* 非空树*/

{

if(DT->lchild) /* 有左孩子*/

DestroyDSTable(DT->lchild); /* 销毁左孩子子树*/

if(DT->rchild) /* 有右孩子*/

DestroyDSTable(DT->rchild); /* 销毁右孩子子树*/

free(DT); /* 释放根结点*/

DT=NULL; /* 空指针赋0 */

}

}

Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree &p) /* 算法9.5(b)*/

{ //在根指针T所指二叉排序树中递归地查找其关键字等于key的数据元素，若查找//成功，则指针p指向该数据元素结点，并返回TRUE，否则指针p指向查找路径上/*访问的最后一个结点并返回FALSE,指针f指向T的双亲，其初始调用值为NULL */ if(!T) /* 查找不成功*/

{

p=f;

return FALSE;

}

else if EQ(key,T->data.key) /* 查找成功*/

{

p=T;

return TRUE;

}

else if LT(key,T->data.key)

SearchBST(T->lchild,key,T,p); /* 在左子树中继续查找*/

else

SearchBST(T->rchild,key,T,p); /* 在右子树中继续查找*/

}

Status InsertBST(BiTree &T, ElemType e)

{ //当二叉排序树T中不存在关键字等于e.key的数据元素时，插入e并返回TRUE，/* 否则返回FALSE。算法9.6*/

BiTree p,s;

if(! SearchBST(T,e.key,NULL,p)) /* 查找不成功*/

{

s=(BiTree)malloc(sizeof(BiTNode));

s->data=e;

s->lchild=s->rchild=NULL;

if(!p)

T=s; /* 被插结点*s为新的根结点*/

else if LT(e.key,p->data.key)

p->lchild=s; /* 被插结点*s为左孩子*/

else

p->rchild=s; /* 被插结点*s为右孩子*/

return TRUE;

}

else

return FALSE; /* 树中已有关键字相同的结点，不再插入*/

}

void TraverseDSTable(BiTree &DT,void(*Visit)(ElemType))

{ /* 初始条件: 动态查找表DT存在，Visit是对结点操作的应用函数*/

/* 操作结果: 按关键字的顺序对DT的每个结点调用函数Visit()一次且至多一次*/ if(DT)

{

TraverseDSTable(DT->lchild,Visit); /* 先中序遍历左子树*/

Visit(DT->data); /* 再访问根结点*/

TraverseDSTable(DT->rchild,Visit); /* 最后中序遍历右子树*/

}

}

void print(ElemType c)

{

cout<

}

BiTree SearchBST(BiTree &T,KeyType key)

{

BiTree p=T;

cout<<"参与比较的关键字为:";

while(p && !EQ(p->data.key,key))

{

cout<data.key<<" ";

if(LT(key,p->data.key))

p=p->lchild;

else

p=p->rchild;

}

if(p)

cout<data.key;

cout<

return p;

}

void main()

{

BiTree bt,P;

int j;

KeyType s;

InitDSTable(bt);

cout<<"1.由{4,19,10,1, 28，6, 13, 5, 12, 7}创建一个二叉排序树bt."<

cout<<"2.判断bt是否为一棵二叉排序树."<

cout<<"3.采用非递归方法查找关键字为6的结点，并输出查找过程中参与比较的全部关键字."<

cout<<"0.退出."<

while(1)

{

cout<<"选择:";

int f;

cin>>f;

switch(f)

{

case 1:

for(j=0;j

if(!InsertBST(bt,r[j])) /* 依次插入数据元素*/

{

cout<<"创建失败."<

exit(0);

}

cout<<"创建成功."<

break;

case 2:

cout<<"中序遍历二叉排序树所得关键字序列为:";

TraverseDSTable(bt,print);

cout<<"\n由于中序遍历二叉排序树所得关键字序列有序,故bt是一棵二叉排序树."<

break;

case 3:

cout<<"请输入待查找值的关键字:";

cin>>s;

P=SearchBST(bt,s);

if(P)

cout<<"查找成功."<

else

cout<<"找不到该关键字!"<

break;

case 0:

DestroyDSTable(bt);

exit(0);

default:

cout<<"选择有误,重新";

}

}

}

运行结果：

程序创建的二叉排序树：

5

19

28

7

10

13

6

4

12

1

4.实现哈希表的相关运算

参考程序中给出了相关类型定义以及一些子程序，实现哈希表的相关运算，请在此基础上编写主程序完成如下功能：

(1)建立｛26，36，41，38，44，15，68，12，06，51，25｝哈希表A[0…14]，

哈希函数为H(k)=key % 13，并采用线性探测法解决冲突。输出哈希表；输

出查找成功的平均查找长度。

(2)在上述哈希表中查找关键字为25的记录；

(3)在上述哈希表中删除关键字为38的记录，然后在表中查找关键字为38 的

记录，输出查找结果。

(4)重新将关键字为38的记录插入表中，然后输出哈希表。

要求输出格式如下：

哈希地址：0 1 2 (12)

关键字值：……………………

探查次数：……………………

源代码：

head.h:

#include

#include

#include //malloc( )

#include // INT ,MAX

#include //EOF,NULL

#include //atoi( )

#include //eof( )

#include //floor( ),ceil( ),abs( )

#include //exit( )

#include //cout,cin

//函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

//OVERFLOW 在math.h 中已定义为3

typedef int Status;

typedef int Boolean; // 布尔类型

main.cpp:

#include"head.h"

#define MaxSize 100 //定义最大哈希表长度

#define NULLKEY -1 //定义空关键字值

#define DELKEY -2 //定义被删关键字值

typedef int KeyType; //关键字类型

//typedef char * InfoType; //其他数据类型

typedef struct

{

KeyType key; //关键字域

//InfoType data; //其他数据域,实验中此域可省略

int count; //探查次数域

}HashTable[MaxSize]; //哈希表类型

void InsertHT(HashTable &ha,int &n,KeyType k,int p) //将关键字k插入到哈希表中{

int i,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].key=k;

ha[adr].count=i;

}

n++;

}

void CreateHT(HashTable &ha,KeyType x[],int n,int m,int p) //创建哈希表

{

int i,n1=0;

for (i=0;i

{

ha[i].key=NULLKEY;

ha[i].count=0;

}

for (i=0;i

InsertHT(ha,n1,x[i],p);

}

int SearchHT(HashTable ha,int p,KeyType k) //在哈希表中查找关键字k

{

int i=0,adr;

while (ha[adr].key!=NULLKEY && ha[adr].key!=k)

{

i++; //采用线性探查法找下一个地址

adr=(adr+1) % p;

}

if (ha[adr].key==k) //查找成功

return adr;

else //查找失败

return -1;

}

int DeleteHT(HashTable ha,int p,int k,int &n) //删除哈希表中关键字k {

int adr;

adr=SearchHT(ha,p,k);

if (adr!=-1) //在哈希表中找到该关键字

{

ha[adr].key=DELKEY;

n--; //哈希表长度减1

return 1;

}

else //在哈希表中未找到该关键字

return 0;

}

void DispHT(HashTable &ha,int n,int m) //输出哈希表

{

int i;

printf(" 哈希表地址\t");

for (i=0;i

printf(" %3d",i);

printf("\n");

printf(" 哈希表关键字\t");

for (i=0;i

if (ha[i].key==NULLKEY || ha[i].key==DELKEY)

printf(" "); //输出3个空格

else

printf(" %3d",ha[i].key);

printf("\n");

printf(" 搜索次数\t");

for (i=0;i

if (ha[i].key==NULLKEY || ha[i].key==DELKEY)

printf(" "); //输出3个空格

else

printf(" %3d",ha[i].count);

}

void calASL(HashTable &ha,int n,int m)

{

float avg=0;

for (int i=0;i

if (ha[i].key!=NULLKEY && ha[i].key!=DELKEY)

avg=avg+ha[i].count;

avg=avg/n;

printf("\t平均搜索长度ASL(%d)=%g\n",n,avg);

}

void main()

{

HashTable hash;

int n=11,m=15,p=13,f,i;

KeyType s,x[]={26,36,41,38,44,15,68,12,06,51,25};

cout<<"1.建立哈希表."<

cout<<"2.输出哈希表."<

cout<<"3.计算平均搜索长度."<

cout<<"4.查找关键字."<

cout<<"5.删除关键字."<

cout<<"6.插入关键字."<

cout<<"0.退出."<

while(1)

{

cout<<"\n选择:";

cin>>f;

switch(f)

{

case 1:

CreateHT(hash,x,n,m,p);

cout<<"\t创建成功."<

break;

case 2:

cout<<"\t\t -------------------------哈希表-------------------------"<

DispHT(hash,n,m);

cout<<"\t\t --------------------------------------------------------"<

break;

case 3:

calASL(hash,n,m);

break;

case 4:

cout<<"\t输入要查找的关键字:";

cin>>s;

i=SearchHT(hash,p,s);

if(i!=-1)

cout<<"\t"<

else

cout<<"\t查找失败."<

break;

case 5:

cout<<"\t输入要删除的关键字:";

cin>>s;

if(DeleteHT(hash,p,s,n))

cout<<"\t删除成功."<

else

cout<<"\t在哈希表中未找到该关键字."<

break;

case 6:

cout<<"\t输入要插入的关键字:";

cin>>s;

InsertHT(hash,n,s,p);

cout<<"\t插入成功."<

break;

case 0:

exit(0);

default:

cout<<"\n选择有误,重新选择.";

}

}

}

运行结果：

【小结或讨论】

通过本次实验，掌握了顺序查找、二分查找、二叉排序树和哈希表的相关算法和运算，并且能够编程实现相应的功能。

实验内容1里面的语句“ST.elem[0].key=key;”目的在于免去查找过程中每一步都要检测整个表是否查找完毕，ST.elem[0]起到了监视哨的作用，提高了程序的效率。

在折半查找过程中的判定树不是完全二叉树，但它的叶子结点所在层次之差最多为1，从而n个结点的判定树的深度和n个结点的完全二叉树的深度相同。

折半查找的效率比顺序查找高，但折半查找只适用于有序表，且限于顺序存储结构。

二叉排序树既拥有类似于折半查找的特性，又采用了链表作存储结构，因此是动态

查找的一种适宜表示。中序遍历二叉排序树可得到一个关键字的有序序列。

对于不同的关键字可能得到同一哈希地址，即产生冲突，通常采用的处理冲突的方

法有以下几种：开放定址法、再哈希法、链地址法和建立一个公共溢出区。本次实验用的是开放定址法中线性探测再散列。

发生冲突的可能性和哈希表的装填因子(表中填入的记录数/哈希表的长度)有关，装

填因子越小，发生冲突的可能性就越小；相反就越大。