#头歌数据结构实验十一查找的实现

最新推荐文章于 2024-03-24 18:00:54 发布

千之浔

最新推荐文章于 2024-03-24 18:00:54 发布

阅读量3k

点赞数 40

文章标签：数据结构

本文链接：https://blog.csdn.net/2302_79707613/article/details/135334720

版权

第1关：顺序查找

任务描述

本关任务：实现顺序查找。

编程要求

在右侧编辑器中补充代码，完成Search_Seq函数，以实现顺序查找。具体要求如下：

* Search_Seq：在表中查找其关键字等于key的记录，若找到返回该记录在表中位置，否则返回0。

测试说明

可在右侧文件夹中查看step1/Main.cpp文件，以便于你的操作。

平台会对你编写的代码进行测试。

输入说明：第一行输入若干记录的关键字，以-1标志结束。第二行输入待查找的关键字。输出说明：第一行输出静态查找表L中各记录的关键字。第二行输出查找的结果，如果找到，则输出该记录在表中的位置，否则输出not find!

测试输入: 37 21 75 55 64 19 -1 55 //待查找的关键字为55

预期输出： 37 21 75 55 64 19 4 //末尾换行

开始你的任务吧，祝你成功！

最后通关代码：

/*************************************************************

顺序查找实现文件

更新于2020年6月23日

**************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "search.h"

int Search_Seq(SSTable L, KeyType key)

{/*在静态查找表L中采用顺序查找法，查找其关键字等于key的记录，若找到返回该记录在表中位置，否则返回0*/

// 请在这里补充代码，完成本关任务

/********** Begin *********/

int i = 0 ;

while(i<L.length&&key!=L.r[i].key)

i++;

if(L.r[i].key==key)

return i;

else

return 0;

从第一位开始查找，直至数组结束或遇到第一个key值

退出循环

判断退出原因

找到key -- 返回下标【从0开始】

否则 -- 返回0

/********** End **********/

}

void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/

{

int i=1; KeyType x;

scanf("%d",&x);

while(x!=-1)

{

L.r[i++].key=x; scanf("%d",&x);

}

L.length=i-1;

}

void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/

{

int i;

for(i=1;i<=L.length;i++)

printf("%d ",L.r[i].key);

printf("\n");

}

第2关：折半查找

任务描述

本关任务：实现折半查找。

编程要求

在右侧编辑器中补充代码，完成Search_Bin函数，以实现顺序查找。具体要求如下：

* Search_Bin：在递增或递减有序的表中查找其关键字等于key的记录，若找到返回该记录在表中位置，否则返回0。

测试说明

可在右侧文件夹中查看step2/Main.cpp文件，以便于你的操作。

平台会对你编写的代码进行测试。

输入说明：第一行按递增或递减的顺序输入若干记录的关键字，以-1标志结束。第二行输入待查找的关键字。输出说明：第一行输出静态查找表L中各记录的关键字。第二行输出查找的结果，如果找到，则输出该记录在表中的位置，否则输出not find!

测试输入: 19 21 37 55 64 75 -1 55 //待查找的关键字为55

预期输出： 19 21 37 55 64 75 4 //末尾换行

开始你的任务吧，祝你成功！

最后通关代码：

/*************************************************************

折半查找实现文件

更新于2020年6月17日

**************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "search.h"

int Search_Bin(SSTable L, KeyType key)/*在递增有序的顺序表L中折半查找其关键字等于key的记录*/

{

// 请在这里补充代码，完成本关任务

/********** Begin *********/

int mid, low = 0,high = L.length;

//设定初始查找范围,注意此处high初始值为L.length而不是L.length-1

while(low<=high)

{

mid= (high + low)/2;

if(key == L.r[mid].key)//找到返回key值下标

return mid;

if(key < L.r[mid].key)//中间值大于待查值--范围前缩

high = mid - 1;

if(key > L.r[mid].key)//中间值小于待查值--范围后缩

low = mid + 1;

}

return 0;//找不到要返回0 -- not find!

/********** End **********/

}

void SSTableInput(SSTable &L) /*输入若干记录的关键字，存放到静态查找表L中*/

{

int i=1; KeyType x;

scanf("%d",&x);

while(x!=-1)

{

L.r[i++].key=x; scanf("%d",&x);

}

L.length=i-1;

}

void SSTableOutput(SSTable L) /*输出静态查找表L中各记录的关键字*/

{

int i;

for(i=1;i<=L.length;i++)

printf("%d ",L.r[i].key);

printf("\n");

}

第3关：二叉排序树的查找

任务描述

本关任务：实现二叉排序树的查找。

编程要求

在右侧编辑器中补充代码，完成Search_BST函数，以实现二叉排序树的查找。具体要求如下：

* Search_BST：在二叉排序树上查找其关键字等于key的记录结点。若找到返回该结点指针，parent指向其双亲；否则返回空指针，parent指向访问路径上最后一个结点。

测试说明

可在右侧文件夹中查看step3/Main.cpp文件，以便于你的操作。

平台会对你编写的代码进行测试。

输入说明：第一行输入若干记录的关键字，以-1标志结束。第二行输入待查找的关键字。输出说明：第一行输出二叉排序树先序遍历的结果。第二行输出二叉排序树中序遍历的结果。第三行输出查找的结果，如果找到，则输出该结点的双亲结点的关键字，否则输出not find!

测试输入: 19 14 66 21 83 27 55 13 10 50 -1 55 //待查找的关键字为55

预期输出： PreOrder:19 14 13 10 66 21 27 55 50 83 //先序遍历的结果 InOrder:10 13 14 19 21 27 50 55 66 83 //中序遍历的结果 27 //末尾换行

开始你的任务吧，祝你成功！

最后通关代码：

/*************************************************************

二叉排序树的查找实现文件

更新于2020年7月5日

**************************************************************/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "search.h"

BiTree Search_BST(BiTree T, KeyType key, BiTNode **parent)

{/*在二叉排序树T上查找其关键字等于key的记录结点。若找到返回该结点指针，parent指向其双亲；否则返回空指针，parent指向访问路径上最后一个结点。*/

// 请在这里补充代码，完成本关任务

/********** Begin *********/

///parent 指向一个存放树根地址的指针

if(T!=NULL)

{

if(key==T->data.key)

return T;

*parent = T;//改变parent true

//parent = &T;error

if(key<T->data.key)

return Search_BST(T->lchild, key,parent);

if(key>T->data.key)

return Search_BST(T->rchild, key,parent);

}

else

return NULL;

if(!T||key==T->data.key)

return T;

由 !T 进入if分支

说明T为空，此时直接返回T也可达到返回空的效果

else

{

*parent = T;

if(key<T->data.key)

return Search_BST(T->lchild, key,parent);

else

return Search_BST(T->rchild, key,parent);

}

/********** End **********/

}

void Insert_BST(BiTree *T, RedType r)/*若二叉排序树T中没有关键字为r.key的记录，则插入*/

{

BiTNode *p,*q,*parent;

parent=NULL;

p=Search_BST(*T,r.key,&parent); /*查找*/

if(p) printf("BST中有结点r，无需插入\n");

else

{

p=parent;

q=(BiTNode *)malloc(sizeof(BiTNode)); q->data=r; q->lchild=q->rchild=NULL;

if(*T==NULL) *T=q; /*若T为空，则q为新的根*/

else if(r.key<p->data.key) p->lchild=q;

else p->rchild=q;

}

BiTree Create_BST( ) /*二叉排序树的构造*/

{/*输入若干记录的关键字（以-1标志结束），生成一棵BST，采用二叉链表存储，返回其根指针T*/

BiTree T; RedType r;

T=NULL; /*建空树*/

scanf("%d",&r.key);

while(r.key!=-1)

{

Insert_BST(&T, r);

scanf("%d",&r.key);

}

return T;

}

void PreOrder(BiTree bt) /*先序遍历*/

{

if(bt)

{

printf("%d ",bt->data.key);

PreOrder(bt->lchild);

PreOrder(bt->rchild);

}

void InOrder(BiTree bt) /*中序遍历*/

{

if(bt)

{

InOrder(bt->lchild);

printf("%d ",bt->data.key);

InOrder(bt->rchild);

}

第4关：采用除留余数法加线性探测法建立哈希表

任务描述

本关任务：采用除留余数法加线性探测法建立哈希表。

第5关：在采用除留余数法加线性探测法建立的哈希表中查找数据

任务描述

本关任务：在采用除留余数法加线性探测法建立的哈希表中查找数据，并将查找过程输出。

已知哈希表长度m=13，采用除留余数法加线性探测法建立如下关键字集合的哈希表：(16,74,60,43,54,90,46,31,29,88,77)，除留余数法的哈希函数为：h(k)=k mod 13，散列表的存储空间是一个下标从0开始的一维数组。

构造的哈希表如下：

查找成功时： ASL＝(1×9＋2×1＋4×1) /11 = 15/11 查找失败时： ASL＝(2+1+10+9+8+7+6+5+4+3+2+1+3) /13 = 61/13

编程要求

根据提示，在右侧编辑器补充代码，采用除留余数法加线性探测法建立哈希表，编写函数实现在哈希表在查找数据的过程：

int Find(HashTable H,KeyType K,int &p); // 在开放定址哈希表H中查找关键码为K的元素，若查找成功，以p指示待查数据元素在表中位置，并返回SUCCESS；否则，返回UNSUCCESS

测试说明

平台会对你编写的代码进行测试：

测试输入： 13 13 11 16 74 60 43 54 90 46 31 29 88 77 29

输入说明：第一行输入13，表示输入哈希表的表长第二行输入13，表示除留余数法的模第三行输入11，表示输入数据的个数第四行输入11个整数，表示输入具体的数据第五行输入要查找的数据

预期输出： 哈希地址0～12 0 1 2 3 4 5 6 7 8 9 10 11 12
77 -1 54 16 43 31 29 46 60 74 88 -1 90
哈希地址为3，第1次冲突 哈希地址为4，第2次冲突 哈希地址为5，第3次冲突 哈希地址为6，第4次查找成功 查找成功：29

输出说明：第一行输出哈希表的数据范围第二行输出哈希表的下标第三行输出哈希表中的数据第四行起输出查找数据的过程

开始你的任务吧，祝你成功！

最后通关代码：

#include"stdio.h"

#include"stdlib.h"

#define NULL_KEY -1 // -1为无记录标志

#define SUCCESS 1

#define UNSUCCESS 0

#define DUPLICATE -1

#define N 100 // 数据元素个数

typedef int KeyType; // 设关键字域为整型

struct ElemType // 数据元素类型

{

KeyType key;

};

struct HashTable

{

ElemType *elem; // 数据元素存储基址，动态分配数组

int count; // 当前数据元素个数

int sizeindex; // sizeindex为哈希表表长

};

// 哈希函数的基本操作函数

void InitHashTable(HashTable &H); // 构造一个空的哈希表

void DestroyHashTable(HashTable &H); // 哈希表H存在。操作结果：销毁哈希表H

unsigned Hash(KeyType K); // 哈希函数

void collision(int &p,int d); // 线性探测再散列

int SearchHash(HashTable H,KeyType K,int &p,int &c); // 在开放定址哈希表H中查找关键码为K的元素

int InsertHash(HashTable &H,ElemType e); // 查找不成功时插入数据元素e到开放定址哈希表H中

void TraverseHash(HashTable H,void(*Vi)(int));

void print(int p);

int Find(HashTable H,KeyType K,int &p);

int m=0; // 全局变量, H(key) = key % m

int main()

{

ElemType r[N]={0};

HashTable h;

int i,p,n;

int j;

KeyType k;

InitHashTable(h);

scanf("%d",&m); // H(key) = key % m

scanf("%d",&n); // 数据的个数

for(i=0;i<n;i++)

{

scanf("%d",&r[i].key);

}

for(i=0;i<n;i++)

{ // 插入前N-1个记录

j=InsertHash(h,r[i]);

}

//printf("按哈希地址的顺序遍历哈希表:\n");

TraverseHash(h,print);

//printf("请输入待查找记录的关键字: ");

scanf("%d",&k);

j=Find(h,k,p);

if(j==SUCCESS)

{

printf("查找成功：");

print(h.elem[p].key);

}

else

printf("查找失败\n");

DestroyHashTable(h);

}

// 哈希函数的基本操作函数

void InitHashTable(HashTable &H)

{ // 操作结果：构造一个空的哈希表

int i;

H.count=0; // 当前元素个数为0

scanf("%d",&H.sizeindex ); // 哈希表存储容量

H.elem=(ElemType*)malloc(H.sizeindex*sizeof(ElemType));

for(i=0;i<H.sizeindex;i++)

H.elem[i].key=NULL_KEY; // 未填记录的标志

}

void DestroyHashTable(HashTable &H)

{ // 初始条件：哈希表H存在。操作结果：销毁哈希表H

free(H.elem);

H.elem=NULL;

H.count=0;

H.sizeindex=0;

}

unsigned Hash(KeyType K)

{ // 一个简单的哈希函数(m为全局变量)

return K%m;

}

void collision(int &p,int d) // 线性探测再散列

{ // 开放定址法处理冲突

p=(p+1)%m;

}

int SearchHash(HashTable H,KeyType K,int &p,int &c)

{ // 在开放定址哈希表H中查找关键码为K的元素，若查找成功，以p指示待查数据

// 元素在表中位置，并返回SUCCESS；否则，以p指示插入位置，并返回UNSUCCESS

// c用以计冲突次数，其初值置零，供建表插入时参考。

p=Hash(K); // 求得哈希地址

while( H.elem[p].key!=NULL_KEY && K!= H.elem[p].key )

{ // 该位置中填有记录．并且关键字不相等

c++;

if(c<H.sizeindex)

collision(p,c); // 求得下一探查地址p

else

break;

}

if (K == H.elem[p].key)

return SUCCESS; // 查找成功，p返回待查数据元素位置

else

return UNSUCCESS; // 查找不成功(H.elem[p].key==NULL_KEY)，p返回的是插入位置

}

int InsertHash(HashTable &H,ElemType e)

{ // 查找不成功时插入数据元素e到开放定址哈希表H中，并返回OK；

// 若冲突次数过大，则重建哈希表

int c,p;

c=0;

if(SearchHash(H,e.key,p,c)) // 表中已有与e有相同关键字的元素

return DUPLICATE;

else if(c<H.sizeindex) // 冲突次数c未达到上限，(c的阀值可调)

{ // 插入e

H.elem[p]=e;

++H.count;

return SUCCESS;

}

else

return UNSUCCESS;

}

void TraverseHash(HashTable H,void(*Vi)(int))

{ // 按哈希地址的顺序遍历哈希表

printf("哈希地址0～%d\n",H.sizeindex-1);

for(int i=0;i<H.sizeindex;i++)

// if(H.elem[i].key!=NULL_KEY) // 有数据

Vi(i);

printf("\n");

for(int i=0;i<H.sizeindex;i++)

// if(H.elem[i].key!=NULL_KEY) // 有数据

Vi(H.elem[i].key);

printf("\n");

}

void print(int p)

{

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

}

int Find(HashTable H,KeyType K,int &p)

{ // 在开放定址哈希表H中查找关键码为K的元素，若查找成功，以p指示待查数据

// 元素在表中位置，并返回SUCCESS；否则，返回UNSUCCESS

/********** Begin **********/

p=Hash(K);

int c=0;

while(H.elem[p].key!=NULL_KEY&&H.elem[p].key!=K)

{

c++;

printf("哈希地址为%d，第%d次冲突\n",p,c);

if(c<H.sizeindex)

{

collision(p,c);

}

c++;

if(H.elem[p].key==K)

{

printf("哈希地址为%d，第%d次查找成功\n",p,c);

return SUCCESS;

}

else

{

printf("哈希地址为%d，第%d次查找为空\n",p,c);

return UNSUCCESS;

}

/********** End **********/

}

任务描述

本关讨论散列存储，哈希函数使用除留余数法，冲突解决方法采用独立链表地址法。

第7关：在采用除留余数法加链地址法建立的哈希表中删除数据

任务描述

本关实现在采用除留余数法加链地址法建立的哈希表中删除数据。

#头歌 数据结构 实验十一 查找的实现

任务描述

相关知识

编程要求

测试说明

任务描述

相关知识

编程要求

测试说明

任务描述

相关知识

编程要求

测试说明

第4关：采用除留余数法加线性探测法建立哈希表

任务描述

相关知识

哈希表的基本概念

构造哈希函数的方法

哈希冲突解决方法

开放定址哈希表的存储结构

哈希函数的基本操作函数

编程要求

测试说明

第5关：在采用除留余数法加线性探测法建立的哈希表中查找数据

任务描述

编程要求

测试说明

任务描述

相关知识

哈希表的基本概念

构造哈希函数的方法

哈希冲突解决方法

编程要求

测试说明

第7关：在采用除留余数法加链地址法建立的哈希表中删除数据

任务描述

相关知识

哈希表的基本概念

构造哈希函数的方法

哈希冲突解决方法

编程要求

测试说明

#头歌数据结构实验十一查找的实现