数据结构与算法-静态查找表

于 2023-12-02 15:16:30 发布
阅读量342 收藏 57
点赞数 61
分类专栏： 初阶数据结构与算法 文章标签： 算法 数据结构 c语言 排序算法
本文链接：https://blog.csdn.net/qq_73121173/article/details/134717616
版权

在这里插入图片描述
🌞 “清醒 自律 知进退！”

查找

查找是在一些有序的或无序的数据元素中，通过一定的方法找出与给定关键字相同的数据元素的过程，即根据给定的某个值在查找表中确定一个关键字等于给定的记录或数据元素。查找是信息处理科学中十分重要的操作。

🎈1.查找的相关概念

  1. 查找表是同一类型数据元素（或记录）构成的集合，与4种数据关系中的集合结构对应。由于集合中数据元素之间存在着完全松散的关系。因此，查找表往往要借助其他数据结构来实现相关算法。
  2. 关键字是可以标识一个数据元素（或记录）的数据项，关键字的值被称之为键值。若关键字可以唯一地标识一条记录，则称此关键字为主关键字。
  3. 查找是根据给定的某个值，在查找表中确定一个关键字等于给定值的记录或数据元素的过程。若在查找表中存在与给定值匹配的记录，则查找成功，此时查找的结果可以是整个记录的信息或查找成功标记等。若在查找表中不存在与给定值匹配的记录，则查找不成功，此时查找结果可以是不成功标记，或将被查找记录插入查找表。
  4. 静态查找表是仅对表进行查找操作，而不进行插入和删除操作的查找表。静态查找在查找不成功时，只返回一个不成功标志，不改变查找表，因此表中数据元素的数量不会发生变化。
  5. 动态查找表是在查找的同时对表进行插入和删除操作的表。动态查找在查找不成功时，需要将被查找的记录插入查找表，因此表中数据元素的数量可能会发生变化。
    在这里插入图片描述

🎈2.静态查找表

🔭2.1静态查找表的类定义

#define _CRT_SECURE_NO_WARNINGS 1
#define Max 100
#include <iostream>
using namespace std;
typedef int KeyType;
typedef int InfoType;
typedef int IndexType;
typedef struct 
{
	KeyType key;//KeyType为关键字数据类型
	InfoType otherinfo;//其他域
}SElemType;
class StaticSearchtable
{
private:
	SElemType* elem;
	int length;
public:
	StaticSearchtable()//构造函数，0位留空
	{
		elem = new SElemType[Max + 1];
		length = 0;
	}
	~StaticSearchtable()//析构函数，释放存储空间
	{
		delete[]elem;
		length = 0;
	}
	void Create(int n)//创建n个元素的顺序表
	{
		for (int i = 0; i <= n; i++)
		{
			cin >> elem[i].key >> elem[i].otherinfo;
		}
		length = n;
	}
	int SqSearch(KeyType key);//顺表表查找值等于key的关键字
	int BinSearch(KeyType key);//二分查找值等于key的关键字
	int IndexSearch(IndexType index[Max], KeyType key, int b);//分块查找值等于key的关键字，b为块数
};

🔭2.2顺序查找

🔎顺序查找的主要思想：

  1. 设立哨兵位elem[0].key=key,其作用是防止扫描溢出。
  2. 从表的末端开始向左扫描线性表，依次将扫描到的关键字值和给定值key进行比较，若找到关键字，则查找成功，返回该关键字在顺序表中的下标；否则查找失败，返回0.
int StaticSearchtable::SqSearch(KeyType key)
{
	elem[0].key = key;//哨兵位
	int i = 0;
	for (i = length; elem[i].key != key; i--)//从末端开始向左扫描
	{
		;//空语句
	}
	return i;
}

🔎顺序查找分析：
在这里插入图片描述

🔭2.3二分查找

二分查找又称折半查找，它是一种效率较高的查找方法。二分查找要求线性表采用顺序存储结构且元素有序。类似于顺序查找方法，在存储元素时，数组元素第0位留空。

🔎二分查找的主要思想是每次将待查找记录所在的区间缩小一 半。具体步骤如下：设elem[low..high]是当前的查找区间，首先确定中间点位置mid = [(low+high)/2],然后将待查元素的关键字key值与elem[mid].key比较：（初始时，令low=1,high=length）

  1. mid = [(low+high)/2]
  2. 若key==elem[mid].key,则查找成功，返回mid,即该元素在顺序表中的下标。
  3. 若key<elem[mid].key,则high = mid-1
  4. 若key>elem[mid].key,则low = mid+1
  5. 重复上述操作，直至low>high时，查找失败，此时返回0
int StaticSearchtable::BinSearch(KeyType key)
{
	int low = 1,high = length;
	int mid;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (key == elem[mid].key)
			return mid;
		else if (key < elem[mid].key)
			high = mid - 1;
		else
			low = mid + 1;
	}
	return 0;
}

✅二分查找过程可用二叉树来描述，在构造二叉树的过程中，把当前查找区间的中点位置上的元素作为树根，左子表和右子表的元素分别作为根的左子树和右子树。由此递归得到二叉树，通常称描述查找的过程的二叉树为判定树。判定树的形态与表中个数n相关，与输入示例中的key值无关。

例如，要找到15个数据元素的有序表中的第8个元素仅需比较1次，找到第4和第12个元素需要比较2次，找到第2,6，10和14个元素需要比较3次；找到第1,3，5,7，9,11,13和15个元素需要比较4次。其查找过程如图所示，树中的每个圆圈结点表示表中一个元素，结点中的值表示该元素在表中的位置；圆圈结点表示查找成功，方框结点表示查找失败。若查找失败，则比较过程是一条从判定树的根到某结点的路径，所需关键字比较次数是该路径上圆圈结点的个数。
在这里插入图片描述

🔎二分查找分析：

  1. 判定树为满二叉树：（有序表元素个数为:n=2h-1）
    （1）.查找成功时平均查找长度：
    在这里插入图片描述
    （2）.查找不成功时平均查找长度：h

  2. 判定树为非满二叉树：

（1）.查找成功时平均查找长度：
在这里插入图片描述
（2）.查找不成功时平均查找长度：
在这里插入图片描述

🔎二分查找例题

例：给定18个元素的有序表 {2,5，8,10,15,40,42,55,66,70,72,75,80,88,90,100,108,200}，采用二分查找，试问：
（1）.查找长度为4和5的元素个数分别有多少个？
（2）.若要查找值为15的数据元素，要经过多少次比较？依次与哪些元素进行比较？
（3）.在查找概率相等的情况下，计算查找成功和查找不成功的平均查找长度。
在这里插入图片描述
解：第一问可以直接数第四行和第五行元素的个数：分别是8和3.
第二问数这条路径圆圈结点的个数为比较次数，圆圈内的值为比较的数：
在这里插入图片描述
因此，我们需要进行4次比较，依次与表中的元素66,10,40,15比较。
第三问，在查找概率相等的情况下，查找成功的平均查找长度为：
（11+22+43+84+35）/18=32/9。
查找不成功的平均查找长度为：（413+5*6）/19=82/19

🔭2.4分块查找

🔎 分块查找又称索引顺序查找，它是顺序表查找的一种改进方法，其性能介于顺序查找和二分查找之间。在索引查找方法中，除存储表本身以外，还需存储一个索引表。存储方法如下：

  1. 将线性表elem[1..n]均分为b块，前b-1块中元素个数为s=[n/b]，最后一块即b块的元素个数小于等于s.
  2. 每一块中的关键字不一定有序，但前一块中的最大关键字小于后一块中的最小关键字，即块内无序，块间有序。
  3. 抽取各块的最大关键字及起始位置构成一个索引表index[0..b-1],即index[i]（0<=i<=b-1）中存放第i块的最大关键字和该块在表中的初始位置。

📖索引表的数据类型定义：

typedef struct
{
	KeyType key;
	int link;
}IndexType;

📖分块查找的算法：

int StaticSearchtable::IndexSearch(IndexType index[Max], KeyType key, int b)
{//b为块数
	int low = 0, high = b - 1, mid, i, s;
	if (length % b == 0)
		s = length / b;
	else
		s = length / b + 1;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (index[mid].key >= key)
			high = mid - 1;
		else
			low = mid + 1;
	}
	//在索引表high+1快对应的线性表中顺序查找key
	i = index[high + 1].link;
	while (i <= index[high + 1].link + s - 1 && elem[i].key != key)
	{
		i++;
	}
	if (i <= index[high + 1].link + s - 1)
		return i;//查找成功，返回该元素的下标
	else
		return 0;//查找失败，返回0
}

🔭2.5三种算法的比较分析

  1. 顺序查找的时间复杂度最差，二分查找的时间复杂度最好，分块查找的时间复杂度介于两种之间。
  2. 分块查找需要增加索引数据的空间，空间复杂度最大。
  3. 顺序查找对表没有特殊要求。
  4. 分块查找的数据块之间在物理上可以不连续，插入、删除数据只涉及对应的块，但增加了索引的维护。
  5. 二分查找要求表有序，若表的元素插入与删除很频繁，则维持有序的工作量极大。
  6. 在表不大的时候，一般使用顺序查找。

🌞运行示例：

#define _CRT_SECURE_NO_WARNINGS 1
#define Max 100
#include <iostream>
using namespace std;
typedef int KeyType;
typedef int InfoType;
typedef struct
{
	KeyType key;//KeyType为关键字数据类型
	InfoType otherinfo;//其他域
}SElemType;
typedef struct
{
	KeyType key;
	int link;
}IndexType;
class StaticSearchtable
{
private:
	SElemType* elem;
	int length;
public:
	StaticSearchtable()//构造函数，0位留空
	{
		elem = new SElemType[Max + 1];
		length = 0;
	}
	~StaticSearchtable()//析构函数，释放存储空间
	{
		delete[]elem;
		length = 0;
	}
	void Create(int n)//创建n个元素的顺序表
	{
		for (int i = 0; i <= n; i++)
		{
			cout << "输入第" << i+1 << "个元素的值和下标：";
			cin >> elem[i].key >> elem[i].otherinfo;
		}
		length = n;
	}
	int SqSearch(KeyType key);//顺表表查找值等于key的关键字
	int BinSearch(KeyType key);//二分查找值等于key的关键字
	int IndexSearch(IndexType index[Max], KeyType key, int b);//分块查找值等于key的关键字，b为块数
};
int StaticSearchtable::SqSearch(KeyType key)
{
	elem[0].key = key;//哨兵位
	int i = 0;
	for (i = length; elem[i].key != key; i--)//从末端开始向左扫描
	{
		;//空语句
	}
	if (i >= 0)
		cout << "该数所在顺序表中的下标为:" << i << endl;
	else
		cout << "未找到！" << endl;
	return 0;
}
int StaticSearchtable::BinSearch(KeyType key)
{
	int low = 1, high = length;
	int mid;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (key == elem[mid].key)
		{
			cout << "该数经二分查找下标为：" << mid << endl;
			break;
		}
		else if (key < elem[mid].key)
			high = mid - 1;
		else
			low = mid + 1;
	}
	if(low>high)
		cout << "未找到！" << endl;
	return 0;
}
int StaticSearchtable::IndexSearch(IndexType index[Max], KeyType key, int b)
{//b为块数
	int low = 0, high = b - 1, mid, i, s;
	if (length % b == 0)
		s = length / b;
	else
		s = length / b + 1;
	while (low <= high)
	{
		mid = (low + high) / 2;
		if (index[mid].key >= key)
			high = mid - 1;
		else
			low = mid + 1;
	}
	//在索引表high+1快对应的线性表中顺序查找key
	i = index[high + 1].link;
	while (i <= index[high + 1].link + s - 1 && elem[i].key != key)
	{
		i++;
	}
	if (i <= index[high + 1].link + s - 1)
		return i;//查找成功，返回该元素的下标
	else
		return 0;//查找失败，返回0
}
int main()
{
	StaticSearchtable a;
	a.Create(8);
	a.SqSearch(6);
	a.BinSearch(7);
	return 0;
}

在这里插入图片描述

好啦，关于静态查找表的知识到这里就先结束啦，后期会继续更新学习数据结构与算法的相关知识，欢迎大家持续关注、点赞和评论！❤️❤️❤️

一口⁵个团子
关注
  • 61
    点赞
  • 踩
  • 57
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 58
    评论
专栏目录
数据结构实验报告-静态查找表
04-03
广工的数据结构实验报告-静态查找表，你懂得……
数据结构 静态查找表
11-19
数据结构，静态查找表，C语言开发，界面友好，绝对有价值！！！
查找（一）——静态查找表
m0_52711790的博客
12-13 4756
目录 一、查找的基本概念 二、顺序查找 （线性查找） 1、基本思想 2、核心代码 3、顺序查找设置哨兵 4、顺序查找的优点： 5、顺序查找的缺点： 6、折半查找 7、折半查找判定树 8、线性表查找的特点 三、索引顺序表（分块查找） 1、分块查找表存储结构 2、分块查找的基本思想 3、分块查找的代码举例 静态查找表主要有三种结构： （1）顺序表； （2）有序顺序表； （3）索引顺序表。 针对静态查找表的查找算法主要有： （1）顺序查找（线性查找）； （2）折半查找
C++数据结构之查找——静态查找表（顺序查找、折半查找、分块查找 带有gif以及图示）
m0_56398315的博客
09-15 5515
本文对查找进行介绍并对静态查找进行重点解释和实现，附有GIF动图以及相关图示方便读者进行阅读
算法：静态查找表
最新发布
2301_78145678的博客
06-15 773
不断重复上述过程，直到查找成功，或所有查找区域无记录，查找失败为止。顺序查找（Sequential Search)又叫线性查找，是最基本的查找技术，它的查找过程是：从表中的一个（或最后一个）记录开始，逐个进行记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录；插值查找（Interpolation Search)是根据要查找的关键字key与查找表中最大最小记录的关键字比较后的查找方法，其核心就在于插值的计算公式 (key-a[low])/(a[high]-a[low])。
数据结构---查找
weixin_52847003的博客
11-23 1697
查找算法概述
9.1 查找表：静态查找表
michael_linux的博客，一个小学生。
08-14 1890
顺序查找表 有序查找表 静态查找树表 索引顺序表
数据结构与算法演示程序
04-17
数据结构与算法演示程序，可以单步执行，便于深入理解各种数据结构执行步骤 包含顺序表、链表、栈、串、稀疏矩阵、广义表、二叉树、图、存储管理、静态查找、动态查找、内部排序、外部排序等Pascal语言和C语言描述
详解常用查找数据结构及算法（Python实现）
12-24
静态查找表（Static Search Table）：只做查找操作的查找表。它的主要操作是： 查询某个“特定的”数据元素是否在表中 检索某个“特定的”数据元素和各种属性 动态查找表（Dynamic Search Tabl
静态查找表算法
03-16
静态查找表算法
静态查找表。实现有序表的折半查找算法
05-22
静态查找表。实现有序表的折半查找算法 静态查找表。实现有序表的折半查找算法 静态查找表。实现有序表的折半查找算法静态查找表。实现有序表的折半查找算法
静态查找表 数据结构 （c语言版）
06-17
静态查找表 课程设计 基本操作的实现 和 有关数据测试
查找：静态查找表的几种查找方法:顺序查找、折半查找、分块查找
MillinZhang的博客
10-21 1832
查找——顺序查找、折半查找、分块查找
数据结构 第八章 查找(静态查找表)
一路生花
02-11 1059
1、集合中的数据元素除了属于同一集合外,没有任何的逻辑关系2、在集合中,每个数据元素都有一个区别于其他元素的唯一标识(键值或者关键字值)5、唯一 一个的数据结构是。
25、静态查找表（顺序表、索引顺序表、静态树表、折半查找）
hopegrace的博客
03-06 1203
一、基本概念 1、查找表：同一类型的数据元素（记录）构成的集合。 2、静态查找表：对查找表只进行查找操作。动态查找表：不仅进行查找操作，而且在查找过程中还伴随着插入（查找的数据元素不在表中时）、删除某个数据元素的操作。 3、关键字(key)：是数据元素（或记录）的某个数据项的值，用它可标识（识别）一个数据元素(或记录)。 4、平均查找长度(ASL)：需和给定值进行比较的关键字个数的期望。 ...
数据结构与算法－静态查找表
越陌度阡
06-08 1338
顺序查找 顺序表的结构定义如下： // 静态表的表长 const int Maxsize = 20; typedef struct { // 关键字 KeyType key; }TableElm; typedef struct { TableElm elm[Maxsize +1]; // 最后一个元素的下标 int n; }SqTable 静态查找表中数组的第0个单元，用于设置“岗哨”，以便简化查找运算的实现，数据存放在数组的第1到第n个单元中，第n+1
数据结构之静态查找表——顺序查找、折半查找与分块查找
轻舟终过万重山
11-26 3889
前言 在非数值运算问题中，数据存储量一般很大，为了能在大量信息中找到某些值，就需要用到查找技术。而为了提高查找效率，就需要对一些数据进行排序。查找和排序是两大重要技术，其数据处理量几乎占到数据总处理量的80%以上，所以查找与排序的有效性直接就影响到基本算法的有效性。本篇文章主要来讨论查找技术中的静态查找，主要包括顺序查找法、折半查找法以及分块查找法。 关于查找 查找表：是由同一类型的数据元素(或记录)构成的集合。由于“集合”中的数据元素之间存在着松散的关系，没有严格的前驱和后继的关系，因此...
静态查找表的操作
奈川直子
12-08 1645
一、操作要求 1．根据输入的查找表的表长n和n个关键字值，建立顺序查找表； 2．用顺序查找方法在上述顺序查找表中查找与已经给定关键值相等的记录； 3．选择一种排序方法对1中建立的顺序查找表进行排序； 4．在3中的有序查找表中用二分查找方法查找与已经给定关键值相等的记录 ； 5．编写main函数，设计菜单使用户能通过菜单的选择多次通过调用上述功能函数来实现所选择的查找操作，并且在每次操作后都输出其操作结果：若查找成功，则输出“查找成功”并输出这条记录在表中的位置，否则输出“查找失败”。 二、代码实
数据结构排序与折半查找算法说明
06-03
排序是将一组无序的数据按照一定的规则进行排列的过程。常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。...如果需要进行动态查找，需要使用其他数据结构，如二叉查找树、红黑树等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 58
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一口⁵个团子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值