算法练习-常用查找算法复现

最新推荐文章于 2023-06-19 09:30:40 发布
最新推荐文章于 2023-06-19 09:30:40 发布
阅读量1k 收藏 3
点赞数
分类专栏： 数据结构作业 文章标签： 顺序查找 折半查找 二叉排序树 B-树 查找算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65185254/article/details/128490274
版权

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

//算法7.1　顺序查找
#include<iostream>
#include<stdio.h>
#include <fstream>
using namespace std;
#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 x;
    while(cin >> x)
    {
        L.R[ ++ L.length].key = x;
    }



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

int Search_Seq(SSTable ST, int key){
    //在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为
    //该元素在表中的位置，否则为0
    /***********************Begin**********************/
    ST.R[0].key = key;
    
    int i;
    for(i = ST.length;ST.R[i].key != key;i -- );
    return i;
	 
	/*********************** 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）

//算法7.3　折半查找
#include<iostream>
#include<stdio.h>
#include<fstream>
using namespace std;
#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 x;
    while(cin >> x)
    {
        L.R[++ L.length].key = x;
    }



/*********************** 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(key == ST.R[mid].key) return mid;
        else if(key < ST.R[mid].key) high = mid - 1;
        else low = mid + 1;
    }

    return 0;
  
/*********************** 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）

//算法7.4　二叉排序树的递归查找
//算法7.5　二叉排序树的插入
//算法7.6　二叉排序树的创建
//算法 7.7　二叉排序树的删除
#include<iostream>
using namespace std;
#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)
    {
        BSTNode *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;
    while(cin >> e.key && e.key != '#')
        InsertBST(T,e);
/*********************** End **********************/
}//CreatBST

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

    while(p)
    {
        if(p -> data.key == key) break;
        f = p;
        if(p -> data.key > key) p = p -> lchild;
        else p = p -> rchild;
    }

    if(!p) return ;

    BSTree q = p;
    if(p -> lchild && p -> rchild) 
    {
        BSTree s = p -> lchild;
        while(s -> rchild)
        {
            q = s;
            s = s -> rchild;
        }
        p -> data = s -> data;
        if(q != p) q -> rchild = s -> lchild;
        else q -> lchild = s -> lchild;
        delete s;
        return ;
    }
    else if(!p -> rchild) p = p -> lchild;
    else if(!p -> lchild) p = p -> rchild;

    if(!f) T = p;
    else if(q == f -> lchild) f -> lchild = p;
    else f -> rchild = p;
    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)

//算法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**********************/
    int x = K;
    BTree ap = NULL;
    bool finished = false;

    while(q && !finished)
    {
        Insert(q,i,x,ap);
        if(q -> keynum < m) finished = true;
        else
        {
            int s = m / 2;
            split(q,s,ap);
            x = q -> key[s];
            q = q -> parent;
            if(q) i = Search(q,x);
        }
    }

    if(!finished) NewRoot(T,q,x,ap);
    return OK;
/*********************** End **********************/
}							//InsertBTree

//算法7.8　B-树的查找
Result SearchBTree(BTree &T, int key){
/***********************Begin**********************/
     BTree p = T,q = NULL;
    bool found = false;
    int i = 0;

    while(p && !found)
    {
        i = Search(p,key);
        if(i > 0 && p -> key[i] == key) found = true;
        else 
        {
            q = p;
            p = p -> ptr[i];
        }
    }

    if(found) return {p,i,1};
    else return {q,i,0};
/*********************** 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）

#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**********************/
    int H0 = H(key);
    if(HT[H0].key == NULLKEY) return -1;
    else if(HT[H0].key == key) return H0; 
    else 
    {
        for(int i = 1;i < m;i ++ )
        {
            int Hi = (H0 + i) % m;
            if(HT[Hi].key == NULLKEY) return -1;
            else if(HT[Hi].key == key) return Hi;
        }

        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;
	}
}

头歌作业
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
头歌数据结构 第1关：顺序表的实现之查找功能
m0_73938781的博客
04-23 805
【代码】头歌数据结构 第1关：顺序表的实现之查找功能。
何恺明 matlab,[论文复现]何恺明博士CVPR2009去雾算法(1)
weixin_34976470的博客
03-17 901
一、前言近期打算研读一下何博士第一篇文章，复现其论文算法，主要参考的博文有：[1] Kaiming He论文心得https://www.cnblogs.com/molakejin/p/5708883.html[2] 论文原理、实现与效果http://www.cnblogs.com/Imageshop/p/3281703.html[3] 论文原文及相关资料下载http://kaiminghe....
查找算法实例
weixin_47873669的博客
09-17 256
查找算法实例： 二分查找法 < 插值二分查找法 @Test public void test(){ int[] addr = {1,2,3,4,5,6,7,8}; int i = DichotomyLookUp(addr, 0, addr.length-1, 8); System.out.println(i); } /** * 二分查找法 */ public int DichotomyLookU
大数据面试题——如何找出访问最多的IP
weixin_30670925的博客
11-28 438
问题描述： 现有海量日志数据保存在一个超大的文件中，该文件无法直接存入内存，要求从 中提取某天访问BD次数最多的IP 分析解读： 由于这个题目只关心某一天访问次数最多的IP，因此可以首先对文件进行一次遍历，把这一天访问的IP的相关信息记录到一个单独的文件中。接下来可以用之前的方法来进行求解。唯一需要确定的是把一个大文件分成多少个小文件比较合适。以IPV...
二分查找算法 四种题型六道题目总结，从此二分不迷路！
清风Python
07-14 1800
前言 二分查找在算法中一般有四类题目： 排序或通过排序后的数组，快速求某个值的下标 35.搜索插入位置 求某个值在数组中的左右端点 34.在排序数组中查找元素的第一个和最后一个位置 (中等) 通过条件判断进行二分查找 278.第一个错误的版本 875.爱吃香蕉的珂珂(中等) 局部有序的二分查找 33.搜索旋转排序数组(中等) 81.搜索旋转排序数组II(中等)...
leetcode算法专题训练：七.查找专题
Worthy_Wang的博客
01-29 706
七.二分法专题 33. 搜索旋转排序数组 81. 搜索旋转排序数组 II 153. 寻找旋转排序数组中的最小值 154. 寻找旋转排序数组中的最小值 II 34. 在排序数组中查找元素的第一个和最后一个位置 剑指 Offer 53 - II. 0～n-1中缺失的数字 35.搜索插入位置 69.x的平方根 74.搜索二维矩阵 4.寻找两个正序数组的中位数 七.二分法专题 33. 搜索旋转排序数组 题目描述:升序排列的整数数组 nums 在预先未知的某个点上进行了旋转（例如， [0,1,2,4,5.
算法设计与分析 考试重点内容源代码
12-22
时间复杂度表示算法执行时间与输入规模的关系，常用的大O记法可以帮助我们理解算法在最坏情况下的运行速度。例如，线性搜索的时间复杂度是O(n)，而二分查找则是O(log n)。空间复杂度衡量了算法在执行过程中所需的...
每天一个PythonChallenge《任务三》-内含源码以及设计说明书(可以自己运行复现).zip
05-08
在这个PythonChallenge《任务三》中，我们探讨的是一系列基于Python编程的练习，旨在提升技能、理解和解决问题的能力。挑战可能涵盖了各种Python基础知识，包括语法、数据结构、函数、模块、异常处理、文件操作等。...
经典数据结构算法的flash演示
10-09
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关...同时，随着技术的发展，可以考虑使用现代工具，如JavaScript可视化库（如D3.js）来复现这些经典的算法演示，以便于在新的技术环境中继续学习和分享。
ACM-NOI-CSP竞赛宝典策略、代码与实战经验共享-acm和noip
最新发布
06-28
- **基础算法**：包括但不限于排序算法（快速排序、归并排序）、查找算法（二分查找）、递归与分治等。 - **数据结构**：掌握链表、树（二叉树、红黑树）、图（邻接矩阵、邻接表）等常见数据结构的特性和应用场景。 ...
Educoder头歌数据结构-二叉排序树的查找
qq_50848214的博客
11-30 7998
二叉排序树的查找 第1关：顺序查找 /************************************************************* 顺序查找 实现文件 更新于2020年6月23日 **************************************************************/ int Search_Seq(SSTable L, KeyType key) {/*在静态查找表L中采用顺序查找法，查找其关键字等于key的记录
头歌：实现顺序表中数据的查找功能
m0_73147943的博客
03-23 8412
头歌实践教学平台数据结构的 1数据结构-顺序表及其应用的答案
查找：折半查找、平衡二叉树、散列表（习题-1、5、6）
m0_65185254的博客
12-30 927
数据结构
Educoder头歌数据结构顺序表及其应用
热门推荐
qq_50848214的博客
11-05 1万+
头歌实践平台答案 数据结构-顺序表及其应用 第1关：顺序表的实现之查找功能 /************************************************************* 顺序表的实现之查找功能 实现文件 更新于2020年4月13日 **************************************************************/ void SL_GetAt(SqList L, int i, ElemType &e)
7-1顺序查找（数据结构）
欢迎来到我的博客
05-20 1975
一.基础知识 1.查找——线性结构——顺序查找 2.查找方式：从头至尾（或从尾至头）依次查找 3.查找长度：比较次数 eg.找到43需要比较9次 4.平均查找长度ASL ①等概率（通常情况） ②不等概率（见后文） （1）查找成功 找到26，查找长度2 找到30，查找长度3 查找每个是等概率的，即1/8 ASL=1×1/8+2×1/8+2×1/8+3×1/8+3×1/8+3×1/8+3×1/8+4×1/8 =(1+2×2+3×4+4×1)/8=2.625 一个成功结点的查找长度=自身所在层数 （2）查找失
（数据结构 C语言）线性表的折半查找，概念与简单实现
weixin_45944348的博客
07-05 3057
折半查找( Binary Search )也称二分查找，它是一种效率较高的查找方法。 但是，折半查找 要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。在下面及后续的讨论中， 均假设有序表是递增有序的。 折半查找的查找过程为:从表的中间记录开始，如果给定值和中间记录的关键字相等，则查 找成功;如果给定值大于或者小于中间记录的关键字，则在表中大于或小于中间记录的那一- 半中 查找，这样重复操作，直到查找成功，或者在某一步中查找区间为空， 则代表查找失败。 折半查找每一次查 找比较都使查找范围缩小-
[数据结构]【C++】实验七 查找实验 7.1 实验目的(1) 掌握顺序表的查找方法，尤其是二分查找方法。(2) 掌握二叉排序树的建立及查找。 查找是软件设计中的最常用的运算，查找所涉
m0_73952999的博客
06-19 548
首先，如前面的任务一样，根据文件读写到的数据查找二叉排序树中的对应节点，在传入数据中，利用lu_all来记录查找的次数。前者可通过顺序排序后进行二分查找的方法进行查找。此题我有两种实现方法，首先第一种通过输入的各个元素值，构建正确的二叉排序树，通过返回对应的二叉树根节点指针与题中所给的数据挨个元素经行对比，进行中序遍历，与题中数据对比后，若有数据不同则二叉排序树并非正确。测试数据：在任务(1)中第一组测试数据所构造的二叉排序树中，分别查找下列元素： 150，70，160，190，10，55，175。
查找算法2——折半查找
凌空的桨
12-06 8806
从小到大排列的有序序列。折半查找的算法描述如下： 将待查找元素与表中间的元素进行比较，如果两者相等，则说明查找成功；否则利用中间位置将表分成两部分，如果待查找元素小于中间位置的元素值，则继续与前一个子表的中间位置元素记性比较；否则与后一个子表的中间位置元素进行比较。不断重复上述操作，直到找到与待查找元素相等的元素，表明查找成功。如果子表为空表，表明查找失败。 【示例】 一个有序顺序表为7，1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值