一个不知名大学生，江湖人称菜狗
original author: jacky Li
Email : 3435673055@qq.com

Time of completion：2023.1.1
Last edited: 2023.1.1

算法练习-常用查找算法复现（PS：1 -- 3自己写的，4、5懒得写了，直接拿的同学的）

第1关：顺序查找（算法7.1和7.2）

任务描述

相关知识

编程要求

测试说明

参考代码

第2关：折半查找（算法7.3）

任务描述

相关知识

编程要求

测试说明

参考代码

第3关：二叉排序树和查找（算法7.4-7.7）

任务描述

相关知识

编程要求

测试说明

参考代码

第4关：B- 树的查找和插入（算法7.8和7.9）

任务描述

相关知识

编程要求

测试说明

参考代码

第5关：散列表查找（算法7.10）

任务描述

相关知识

编程要求

测试说明

参考代码

作者有言

算法练习-常用查找算法复现（PS：1 -- 3自己写的，4、5懒得写了，直接拿的同学的）

第1关：顺序查找（算法7.1和7.2）

任务描述

本关任务：用顺序查找法找出关键字在列表中的位置，下标由1开始计数。

编程要求

根据提示，在右侧编辑器Begin和End间补充代码，完成顺序查找之任务。

测试说明

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

测试输入（共两行，第一行为待查找的关键字，第二行为以空格分隔的顺序表各元素：

4

0 1 2 3 4 5

预期输出：

找到4位置为5

测试输入：

7

0 1 2 3 4 5

预期输出：

未找到7

`参考代码`

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <cstring>
#include <unordered_map>
#include <unordered_set>

#define IOS std::ios::sync_with_stdio(false)
#define inf 0x3f3f3f3f
#define YES cout << "YES" << endl;
#define yes cout << "yes" << endl;
#define no cout << "no" << endl;
#define NO cout << "NO" << endl;
//#define int long long
#define x first
#define y second
//#define cmp [&](PII a, PII b){ return a.y < b.y; }

const int N = 5e5+10, mod = 1e9+7, M = 1e7+5, K = 1e5+10, Z = 2e5+7;

using namespace std;
typedef long long LL;
typedef pair<int, int> PII;

#define MAXSIZE 10000
#define OK 1;

typedef struct{
	int key;//关键字域
}ElemType;

typedef struct{
	ElemType *R;
	int length;
}SSTable;

int InitList_SSTable(SSTable &L)
{
    L.R=new ElemType[MAXSIZE];
	if (!L.R)
	{
		cout<<"初始化错误";
		return 0;
	}
	L.length=0;
	return OK;
}

int Insert_SSTable(SSTable &L) //将所有关键字输入顺序表备查
{
	/***********************Begin**********************/
	int n;
	while(scanf("%d", &n) != EOF)
		L.length ++, L.R[L.length].key = n;
	return OK;
	/*********************** End **********************/
}

int Search_Seq(SSTable ST, int key){
    //在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为
    //该元素在表中的位置，否则为0
    /***********************Begin**********************/
	for(int i = 1; i <= ST.length; i ++)
		if(ST.R[i].key == key)
			return i;
	return 0;
	/*********************** End **********************/
}// Search_Seq

void Show_End(int result,int testkey)
{
	if(result==0)
		cout<<"未找到"<<testkey<<endl;
	else
		cout<<"找到"<<testkey<<"位置为"<<result<<endl;
	return;
}
int main()
{
	int testkey1;
    scanf("%d",&testkey1);
    SSTable ST;
	InitList_SSTable(ST);
	Insert_SSTable(ST);
	int result;
	result=Search_Seq(ST, testkey1);
	Show_End(result,testkey1);
}

第2关：折半查找（算法7.3）

任务描述

本关任务：用折半查找算法查找关键字在有序列表中的位置，下标从1开始计数。

编程要求

根据提示，在右侧编辑器Begin和End间补充代码，完成折半查找之任务。

测试说明

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

测试输入（共两行，第一行为待查找的关键字，第二行为以空格分隔的顺序表各元素：

4

0 1 2 3 4 5

预期输出：

找到4位置为5

测试输入：

7

0 1 2 3 4 5

预期输出：

未找到7

参考代码

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <cstring>
#include <unordered_map>
#include <unordered_set>

#define IOS std::ios::sync_with_stdio(false)
#define inf 0x3f3f3f3f
#define YES cout << "YES" << endl;
#define yes cout << "yes" << endl;
#define no cout << "no" << endl;
#define NO cout << "NO" << endl;
//#define int long long
#define x first
#define y second
//#define cmp [&](PII a, PII b){ return a.y < b.y; }

const int N = 5e5+10, mod = 1e9+7, M = 1e7+5, K = 1e5+10, Z = 2e5+7;

using namespace std;
typedef long long LL;
typedef pair<int, int> PII;

#define ERROR 0
#define MAXSIZE 2000
#define OK 1;

typedef struct{
	int key;//关键字域
}ElemType;

typedef struct{
	ElemType *R;
	int length;
}SSTable;

int InitList_SSTable(SSTable &L)
{
	L.R=new ElemType[MAXSIZE];
	if (!L.R)
	{
		cout<<"初始化错误";
		return 0;
	}
	L.length=0;
	return OK;
}

int Insert_SSTable(SSTable &L) //将所有关键字输入顺序表备查
{
/***********************Begin**********************/
	int n;
	while(scanf("%d", &n) != EOF)
		L.length ++, L.R[L.length].key = n;
	return OK;
/*********************** End **********************/
}

int Search_Bin(SSTable ST,int key) {
   // 在有序表ST中折半查找其关键字等于key的数据元素。若找到，则函数值为
   // 该元素在表中的位置，否则为0
/***********************Begin**********************/
	int low = 1, high = ST.length;
	while(low <= high)
	{
		int mid = (low + high) >> 1;
		if(ST.R[mid].key == key) return mid;
		else if(key > ST.R[mid].key) low = mid + 1;
		else high = mid - 1;
	}  
	return ERROR;
/*********************** End **********************/
}// Search_Bin

void Show_End(int result,int testkey)
{
	if(result==0)
		cout<<"未找到"<<testkey<<endl;
	else
		cout<<"找到"<<testkey<<"位置为"<<result<<endl;
	return;
}

int main()
{
	int testkey1;
    scanf("%d",&testkey1);
    SSTable ST;
	InitList_SSTable(ST);
	Insert_SSTable(ST);
	int result;
	result=Search_Bin(ST, testkey1);
	Show_End(result,testkey1);
}

第3关：二叉排序树和查找（算法7.4-7.7）

任务描述

本关任务：实现二叉排序树的创建、插入、查找、删除操作。

编程要求

根据提示，在右侧编辑器Begin和End间补充代码，完成折半查找之任务。

测试说明

平台会对你编写的代码进行测试，以下为两个测试用例的例子。

测试输入（共3行：第1行，为构造二叉排序树的字符序列，行末为结束符号#；第2行为单个字符，是需要在二叉排序树中查找的字符；第3行为单个字符，是需要从二叉排序树中删除的字符):

参考代码

#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <cstring>
#include <unordered_map>
#include <unordered_set>

#define IOS std::ios::sync_with_stdio(false)
#define inf 0x3f3f3f3f
#define YES cout << "YES" << endl;
#define yes cout << "yes" << endl;
#define no cout << "no" << endl;
#define NO cout << "NO" << endl;
//#define int long long
#define x first
#define y second
//#define cmp [&](PII a, PII b){ return a.y < b.y; }

const int N = 5e5+10, mod = 1e9+7, M = 1e7+5, K = 1e5+10, Z = 2e5+7;

using namespace std;
typedef long long LL;
typedef pair<int, int> PII;

#define ENDFLAG '#'
typedef struct ElemType{	
	char key;
}ElemType;

typedef struct BSTNode{
	ElemType data;	//结点数据域
	BSTNode *lchild,*rchild;	//左右孩子指针
}BSTNode,*BSTree;


//算法7.4　二叉排序树的递归查找
BSTree SearchBST(BSTree T,char key) {
  //在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素
  //若查找成功，则返回指向该数据元素结点的指针，否则返回空指针
/***********************Begin**********************/
	if(!T || key == T -> data.key) return T;
	else if (key < T -> data.key)  return SearchBST(T -> lchild, key);
	else return SearchBST(T -> rchild, key);  
/*********************** End **********************/
} // SearchBST



//算法7.5　二叉排序树的插入
void InsertBST(BSTree &T,ElemType e ) {
  //当二叉排序树T中不存在关键字等于e.key的数据元素时，则插入该元素
/***********************Begin**********************/
	if(!T) 
	{                				
		BSTree S = new BSTNode; 
        S -> data = e, S -> lchild = S -> rchild = NULL, T = S;
	}
	else if (e.key < T -> data.key) InsertBST(T -> lchild, e);	
	else if (e.key > T -> data.key) InsertBST(T -> rchild, e);	
/*********************** End **********************/
}// InsertBST



//算法7.6　二叉排序树的创建
void CreateBST(BSTree &T ) {
  //依次读入一个关键字为key的结点，将此结点插入二叉排序树T中
/***********************Begin**********************/
	T=NULL; ElemType e; cin >> e.key;
	while(e.key != ENDFLAG)
	{
    	InsertBST(T, e);
    	cin >> e.key;			
	}   
/*********************** End **********************/
}//CreatBST

void DeleteBST(BSTree &T,char key) {
  //从二叉排序树T中删除关键字等于key的结点
/***********************Begin**********************/
	BSTree p = T, f = NULL, q, s;      //初始化

  /*------------下面的while循环从根开始查找关键字等于key的结点*p-------------*/
  while(p)
  {                  
	if(p -> data.key == key) break;  	      	//找到关键字等于key的结点*p，结束循环
	f = p;                                			//*f为*p的双亲结点
	if(p -> data.key > key)  p = p -> lchild;     	//在*p的左子树中继续查找
	else p = p -> rchild;  	                  		//在*p的右子树中继续查找
	}
	if(!p) return;                         		//找不到被删结点则返回

/*―考虑三种情况实现p所指子树内部的处理：*p左右子树均不空、无右子树、无左子树―*/
	if((p -> lchild) && (p -> rchild)) 
	{     		//被删结点*p左右子树均不空
		q = p, s = p->lchild;
		while(s -> rchild)                			//在*p的左子树中继续查找其前驱结点，即最右下结点
			q = s, s = s -> rchild;	         		//向右到尽头
		p -> data = s -> data;               			//s指向被删结点的“前驱”
		if(q != p)
			q -> rchild = s->lchild;     	//重接*q的右子树
		else q -> lchild = s -> lchild;        		//重接*q的左子树
		delete s;
	}//if
	else
	{
		if(!p->rchild)               		//被删结点*p无右子树，只需重接其左子树
			q = p, p = p -> lchild; 
		else if(! p -> lchild)               		//被删结点*p无左子树，只需重接其右子树
			q = p, p = p -> rchild;
	/*――――――――――将p所指的子树挂接到其双亲结点*f相应的位置――――――――*/
		if(!f) T = p;                       			//被删结点为根结点
		else if (q == f -> lchild) f -> lchild = p;   	//挂接到*f的左子树位置
		else f -> rchild = p;                 		//挂接到*f的右子树位置
		delete q;
	}
/*********************** End **********************/
}//DeleteBST

//算法 7.7　二叉排序树的删除

//中序遍历
void InOrderTraverse(BSTree &T)
{
/***********************Begin**********************/
	if(T)
	{
		InOrderTraverse(T -> lchild);
		cout << T->data.key;
		InOrderTraverse(T -> rchild);
	}	
/*********************** End **********************/
}

int main()
{
	BSTree T;
	CreateBST(T);
	cout<<"当前有序二叉树中序遍历结果为";
	InOrderTraverse(T);
    cout<<endl;
	char key;//待查找或待删除内容
	cin>>key;
	BSTree result=SearchBST(T,key);
	if(result)
	{cout<<"找到字符"<<key<<endl;}
	else
	{cout<<"未找到"<<key<<endl;}
	cin>>key;
	DeleteBST(T,key);
	cout<<"当前有序二叉树中序遍历结果为";
	InOrderTraverse(T);
}

第4关：B- 树的查找和插入（算法7.8和7.9）

任务描述

本关任务：根据给定数据完成B-树的构建、查找和插入。

编程要求

根据提示，在右侧编辑器补全B-树的插入函数InsertBTree和查找函数SearchBTree的代码，完成对主函数给定数组的B-树构建。

测试说明

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

测试输入：无；

预期输出：

OK

参考代码

//算法7.8　B-树的查找
//算法7.9　B-树的插入
#include<iostream>
using namespace std;
#define FALSE 0
#define TRUE 1
#define OK 1
#define m 3						//B-树的阶，暂设为3
typedef struct BTNode{
	int keynum;					//结点中关键字的个数，即结点的大小
	BTNode *parent;				//指向双亲结点
	int key[m+1];				//关键字矢量，0号单元未用
	BTNode *ptr[m+1];			//子树指针矢量
}BTNode,*BTree;

//- - - - - B-树的查找结果类型定义- - - - -
struct Result{
  BTNode *pt;     							//指向找到的结点
  int i;           							//1..m，在结点中的关键字序号
  int tag;         							//1：查找成功，0：查找失败
}; 	                           


int Search(BTree T,int key)
{
	BTree p=T;	
	int endnum;
	if(p)						//树不为空时
	{
		endnum=p->keynum;		//获得首节点包含的记录个数
	}
	else
	{
		return 0;				//返回没找到
	}
	int i=0;
	if(endnum==0)
	{
		return i;				//树存在，但仅有一个为空根节点
	}
	else if(key>=p->key[endnum])//节点不为空，但当前值比最大的key还大
	{
		i=endnum;
		return i;
	}
	else if(key<=p->key[1])		//节点不为空，但当前值比最小的key还小
	{
		return i;}
	else
	{
		for(i=1;i<endnum;i++)	//有合适的位置，即处于当前结点的最大和最小值之间，或找到了
		{
			if(p->key[i]<=key && key<p->key[i+1])
				return i;
		}
	}
}

void Insert(BTree &q,int i,int x,BTree &ap)
{//将x插入q结点的i+1位置中
	int j;
	for(j=m-1;j>i;j--)			
	{
		//将插入位置之后的key全部后移一位
		q->key[j+1]=q->key[j];
	}
	for(j=m;j>i;j--)
	{
		//相应地也移动其后ptr的位置
		q->ptr[j]=q->ptr[j-1];
	}
	q->key[i+1]=x;//插入x到该位置
	q->ptr[i+1]=ap;
	q->keynum++;
}

void split(BTree &q,int s,BTree &ap)
{	//将q->key[s+1,..,m], q->ptr[s+1,..,m]移入新结点*ap作为右结点
	//原结点作为新的左侧结点
	//中间值被保存在ap[0]->key中，等待找到跳转回InsertBTree（）寻找到到合适的插入位置插入	
	int i;
	ap=new BTNode;
	for(i=s+1;i<=m;i++)
	{	//将q->key[s+1,..,m]保存到ap->key[0,..,m-s+1]中
		//将q->ptr[s+1,..,m]保存到ap->ptr[0,..,m-s+1]中
		ap->key[i-s-1]=q->key[i];	
		ap->ptr[i-s-1]=q->ptr[i];
	}
	if(ap->ptr[0])
	{
		//当ap有子树的时候
		for(i=0;i<=1;i++)
		{
			//将ap的子树的父亲改为ap自己
			ap->ptr[i]->parent=ap;
		}
	}
	ap->keynum=(m-s)-1;
	ap->parent=q->parent;//将ap的父亲改为q的父亲
	q->keynum=q->keynum-(m-s);//修改q的记录个数
}

void NewRoot(BTree &T,BTree q,int x,BTree &ap)//生成含信息（T, x, ap）的新的根结点*T，原T和ap为子树指针
{
	BTree newT=new BTNode;//新建一个结点作为新的根
	
	newT->key[1]=x;//写入新根的key[1]
	newT->ptr[0]=T;//将原来的树根作为新根的左子树
	newT->ptr[1]=ap;//ap作为新根的右子树
	newT->keynum=1;
	newT->parent=NULL;//新根的父亲为空

	ap->parent=newT;//ap的父亲为新根
	T->parent=newT;//T的父亲为新根

	T=newT;//树改成新根引导的
}

//算法7.9　B-树的插入
int InsertBTree(BTree &T,int K,BTree q,int i){
/***********************Begin**********************/



/*********************** End **********************/
}							//InsertBTree

//算法7.8　B-树的查找
Result SearchBTree(BTree &T, int key){
/***********************Begin**********************/



/*********************** End **********************/
}//SearchBTree

void InitialBTree(BTree &T)
{
	//初始化一个空的根
	T->keynum=0;		
	T->parent=NULL;	
	for(int i=0;i<m+1;i++)
	{
		T->ptr[i]=NULL;
	}
}

int main()
{
	BTree T=new BTNode;
	InitialBTree(T);
	//先用SearchBTree()找到要插入的位置，得到一个Result结构体
	//再用InsertBTree()插入数据
	Result result;
	int a[11]={45,24,53,90,3,12,50,61,70,100};
	for(int i=0;i<10;i++)
	{
		result=SearchBTree(T,a[i]);
		if(result.tag==0)
		{
			InsertBTree(T,a[i],result.pt,result.i);
		}
	}
	cout<<"OK";
}

第5关：散列表查找（算法7.10）

任务描述

本关任务：用散列表查找法找出关键字在列表中的位置，下标由1开始计数。

编程要求

根据提示，在右侧编辑器Begin和End间补充代码，完成散列表查找之任务。

测试说明

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

测试输入（共两行，第一行为待查找的关键字，第二行为以空格分隔的散列表中各元素：

55

-1 14 1 68 27 55 19 20 84 79 23 11 10 -1 -1 -1

预期输出：

在第5位置找到

测试输入：

47

-1 14 1 68 27 55 19 20 84 79 23 11 10 -1 -1 -1

预期输出：

未找到

`参考代码`

#include<iostream>
#include<stdio.h>
using namespace std;

//算法7.10　哈希表的查找
//- - - - -开放地址法哈希表的存储表示- - - - -
#define m 16                        			//哈希表的表长
#define NULLKEY 0                 			//单元为空的标记

struct HashTable{
   int  key;		         	 			//关键字项
// InfoType  otherinfo;					//其他数据项
};

//	算法7.10为哈希表查找的算法，采用线性探测法处理冲突。
//	【算法实现】

int H(int key)
{
	int result;
	result=key%13;
	return result;
} 

int SearchHash(HashTable HT[],int key){
  //在哈希表HT中查找关键字为key的元素，若查找成功，返回哈希表的单元标号，否则返回-1 
  /***********************Begin**********************/
  for(int i=1;i<=m;i++)
  {
  	if(HT[i].key==key)
  	  return i;
  }

return -1;
  
  /*********************** End **********************/
}//SearchHash

int main()
{	
	int result,i=0;
	int a[m];
	char end=' ';
	int lookfor;		//lookfor为待查找的元素 
	scanf("%d",&lookfor);
	for(;i<m;i++)
	{
		scanf("%d",&a[i]);
	}
	HashTable HT[m];
	for(i=0;i<16;i++)
	{
		HT[i].key=a[i];
	}
	result=SearchHash(HT,lookfor);
	if(result!=-1)
	{
		cout<<"在第"<<result<<"位置找到"<<endl;
	}
	else
	{
		cout<<"未找到"<<endl;
	}
}