数据结构 C++查找

最新推荐文章于 2025-02-16 00:25:21 发布
原创 最新推荐文章于 2025-02-16 00:25:21 发布 · 1.4k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

数据结构查找 C++

一.查找的基本概念

  被查找对象是由一组元素组成的表或文件，每个元素由若干个数据项组成，并假设每个元素都有一个能唯一标识该元素的关键字。

  1. 若在查找的同时对表做了修改运算（例如插入和删除），则相应的表称为动态查找表，否则为静态查找表。
  2. 若整个查找过程都在内存中进行，则称之为内查找；若查找过程中需要访问外存，则称之为外查找。
  3. 平均查找长度（Average Search Length，ASL）的定义如下：
    ∑ i = 1 n p i c i \sum_{i=1}^n{p_ic_i} \quad i=1∑n​pi​ci​
    其中，n是查找表中元素的个数；pi是查找第i个元素的概率，除特别指出外，均认为每个元素的查找概率相等，即pi=1/n（1≤i≤n）；ci是找到第i个元素所需要进行的关键字比较次数。平均查找长度分为成功查找情况下和不成功查找情况下的平均查找长度两种。前者指在表中找到指定关键字的元素平均所需关键字比较的次数，后者指在表中找不到指定关键字的元素平均所需关键字比较次数。

二.线性表的查找

建立线性表查找的类

#include <iostream>
using namespace std;
#define MAXSIZE 10


class SqListSearch{
	public:
		SqListSearch();
		~SqListSearch();
		int binSearchRe(int low,int high,int k);
		int binSearch(int k);
		int seqSearch(int k);
	private:
		int* R;
		int length;
};

SqListSearch::SqListSearch(){
	R = new int[MAXSIZE]{1,2,3,4,5,6,7,8,9,10};
	length = 10;
}

SqListSearch::~SqListSearch(){
	delete [] R;
}

①顺序查找

int SqListSearch::seqSearch(int k){
	int i=0;
	while(i<length && R[i]!=k){
		i++;
	}
	if(i>=length){
		return 0;
	}else{
		return i+1;
	}
}

②折半查找

  1. 递归查找
int SqListSearch::binSearchRe(int low,int high,int k){
	int mid;
	if(low<=high){
		mid = (low+high)/2;
		if(R[mid]==k){
			return mid+1;
		}
		if(R[mid]>k){
			return binSearchRe(low,mid-1,k);
		}else{
			return binSearchRe(mid+1,high,k);
		}
	}else{
		return -1;
	}
}
  1. 非递归查找
int SqListSearch::binSearch(int k){
	int low=0,high=length-1,mid;
	while(low<=high){
		mid = (low+high)/2;
		if(R[mid]==k){
			return mid+1;
		}
		if(R[mid]>k){
			high = mid-1;
		}
		else{
			low = mid+1;
		}
	}
	return -1;
}

main函数

int main(){
	SqListSearch s;
	int res = s.binSearchRe(0,9,9);
	cout << "递归结果为：" << res << endl;
	res = s.binSearch(9);
	cout << "非递归结果为：" << res << endl;
	return 0;
}

三.树表的查找

二叉排序树（简称BST）又称二叉查找（搜索）树，其定义为，二叉排序树或者空树，或者满足以下性质的二叉树：

  1. 若它的左子树非空，则左子树上所有元素的值均小于根元素的值
  2. 若它的右子树非空，则右子树上所有元素的值均大于根元素的值
  3. 左、右子树本身又各是一棵二叉排序树

建立二叉排序树的类

#include <iostream>
using namespace std;
#define MAXSIZE 100

class Node{
	public:
		int key;
		char data;
		Node *lChild;
		Node *rChild;
};

class BSTree{
	public:
		BSTree();
		~BSTree();
		bool createBSTree(int a[],int n);
		bool insertBSTree(int k);
		bool searchBSTree(int k);
		void dispBSTree();
	private:
		Node *r;
		void destroyBSTree(Node *n);
		Node *findNode1(Node *n,char e);
		bool insertBSTree1(Node *&p,int k);
		bool searchBSTree1(Node *n,int k);
		void dispNode(Node *n);
};


BSTree::BSTree(){
	r = NULL;
}

BSTree::~BSTree(){
	destroyBSTree(r);
}

创建和销毁二叉排序树

void BSTree::destroyBSTree(Node *n){
	if(n!=NULL){
		destroyBSTree(n->lChild);
		destroyBSTree(n->rChild);
		delete n;
	}
}

bool BSTree::createBSTree(int a[],int n){
	int i=0;
	while(i<n){
		if(insertBSTree1(r,a[i])){
			i++;
		}else{
			return false;
		}
	}
	return true;
}

插入元素到二叉排序树

bool BSTree::insertBSTree1(Node *&p,int k){
	if(p==NULL){
		p = new Node();
		p->key=k;
		p->lChild=p->rChild=NULL;
		return true;
	}else if(k==p->key){
		return false;
	}else if(k<p->key){
		return insertBSTree1(p->lChild,k);
	}else{
		return insertBSTree1(p->rChild,k);
	}
}

查找二叉排序树的元素

bool BSTree::searchBSTree(int k){
	return searchBSTree1(r,k);
}

bool BSTree::searchBSTree1(Node *n,int k){
	if(n==NULL){
		return false;
	}
	if(n->key==k){
		return true;
	}
	if(k<n->key){
		return searchBSTree1(n->lChild,k);
	}else{
		return searchBSTree1(n->rChild,k);
	}
}

输出二叉排序树

void BSTree::dispBSTree(){
	dispNode(this->r);
}

void BSTree::dispNode(Node *n){
	if(n!=NULL){
		cout << n->key;
		if(n->lChild!=NULL || n->rChild!=NULL){
			cout << "(";
			dispNode(n->lChild);
			if(n->rChild!=NULL){
				cout << ",";
			}
			dispNode(n->rChild);
			cout << ")";
		}
	}
}

main函数

int main(){
	int num[]={4,9,0,1,8,6,3,5,2,7};
	BSTree t;
	t.createBSTree(num,10);
	t.dispBSTree();
	cout << endl;
	bool b = t.searchBSTree(6);
	if(b){
		cout << "查找成功" << endl;
	}else{
		cout << "查找失败" << endl; 
	}
	return 0;
}

四.哈希表的查找

  哈希表存储的基本思路是，设要存储的对象个数为n，设置一个长度为m（m≥n）的连续内存单元，以每个对象的关键字ki（0≤i≤n-1）为自变量，通过一个被称为哈希函数h(ki)，把ki映射为内存单元的地址（或称下标）h(ki)，并把该对象存储在这个内存单元中。h(ki)也称为哈希地址（又称散列地址）。通常把如此构造的线性表存储结构称为哈希表。

  1. 哈希函数的构造方法
    ①直接定址法：h(ki) = k + c(常量)
    ②除留余数法：h(ki) = k mod p(mod为求余运算，p≤m)
    ③数字分析法

  2. 哈希冲突的解决方法
    当发生哈希冲突时，即ki≠kj(i≠j)，而h(ki)=h(kj)时，通过哈希冲突函数（设为h(kl)，这里l=1,2,3,…,m-1）产生一个新的哈希地址，使h(ki)≠h(kj)
    ①开放地址法
    ②拉链法

建立哈希表的类（除留余数法+开放地址法）

# define NULLKEY -1
# define DELKEY -2
#include <iostream>
using namespace std;

class HashTable{
	public:
		int key;
		int count;
};


	
class HashClass{
	public:
		HashClass();
		HashClass(int len);
		~HashClass();
		void hashDisp();
		void hashSearch(int k);
		bool hashDelete(int k);
		void hashInsert(int k);	
		void hashCreate(int keys[]);
	private:
		HashTable *ht;
		int length;
		int p;
};

HashClass::HashClass(int len){
	ht = new HashTable[len];
	length = len;
	while(len>0){
		if(len%2==1){
			p = len;
			break;
		}
		len--;
	}	
}

HashClass::~HashClass(){
	delete [] ht;
}

创建哈希表

void HashClass::hashCreate(int keys[]){
	for(int i=0;i<length;i++){
		ht[i].key = NULLKEY;
		ht[i].count = 0;
	}
	for(int j=0;j<length;j++){
		hashInsert(keys[j]);
	}
}

void HashClass::hashInsert(int k){
	int i,adr;
	adr = k%p;
	if(ht[adr].key==NULLKEY||ht[adr].key==DELKEY){
		ht[adr].key = k;
		ht[adr].count = 1;
	}else{
		i=1;
		do{
			adr = (adr+1)%length;
			i++;
		}while(ht[adr].key!=NULLKEY&&ht[adr].key!=DELKEY);
		ht[adr].key = k;
		ht[adr].count = 1;
	}
}

删除哈希表中的元素

bool HashClass::hashDelete(int k){
	int adr;
	adr = k%p;
	while(ht[adr].key!=NULLKEY&&ht[adr].key!=DELKEY){
		adr = (adr+1)%length;
		if(ht[adr].key==k){
			ht[adr].key=DELKEY;
			return true;
		}else{
			return false;
		}
	}
	
}

查找哈希表中的元素

void HashClass::hashSearch(int k){
	int i=1,adr;
	adr=k%p;
	while(ht[adr].key!=NULLKEY&&ht[adr].key!=k){
		i++;
		adr = (adr+1)%length;
	}
	if(ht[adr].key==k){
		cout << "查找成功" << endl;
	}else{
		cout << "查找失败" << endl;
	}
}

输出哈希表中的元素

void HashClass::hashDisp(){
	for(int i=0;i<length;i++){
		if(ht[i].key>=16&&ht[i].key<=90){
			int k=ht[i].key;
			cout << k << " "; 
		}else{
			cout << "∧" << " ";
		}
	}
	cout << endl;
}

main函数

int main(){
	HashClass hc(13);
	int num[] = {16,74,60,43,54,90,46,31,29,88,77};
	hc.hashCreate(num);
	hc.hashDisp();
	cout << "查找关键字为29的元素结果：";
	hc.hashSearch(29);
	cout << "删除关键字为77的元素后：";
	hc.hashDelete(77);
	hc.hashDisp();
	cout << "插入关键字为77的元素后："; 
	hc.hashInsert(77);
	hc.hashDisp();
	return 0;
}
【2023王道数据结构】【查找】通过C++实现顺序查找（线性查找STL容器）C、C++完整实现（可直接运行）
CSDN 精品推荐
05-17 556
~~~笔锋至此又怎能平淡而终，故事开始便不承认普通✌✌✌ ✌ 题目及题解持续更新中 【2023王道数据结构目录】课后算法设计题C、C++代码实现完整版大全 题目： 通过C++实现顺序查找（线性查找STL容器） 代码实现： #include <iostream> #include <vector> using namespace std; int Sequence_Search(vector<int> v, int key) { /**********.
C / C++ 数据结构与算法（查找）
Jinxiaoyu886的博客
07-04 575
只是我自己看书、视频的总结 可能不适合其他人看。 查找表：是由同一类型的数据元素（或记录）构成的集合。 关键字：是数据元素中某个数据项的值，也称为键值 查找，就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素或记录 静态查找表：只作查找操作的查找表。主要操作有： 查询某个“特定的”数据元素是否在查找表中。 检索某个“特定的”数据元素和各种属性。 动态查找表：在查找过程中同事插...
6.3 常用的查找方法
芝麻软件工作室的专栏
06-13 715
查找（search）当然也是最常见的运算，就是在数据集合中寻找满足条件的数据对象，找到后进一步给出对象的具体信息，在数据库技术中称为检索（retrieval）。 查找的依据 查找的依据是关键字（key word）是否相同。可以唯一地把资料区分出来的数据被称为主关键字。 例如学生的资料，该资料是一个结构体变量； struct student{     int id ; //学号
二分法
qq_36691454的博客
08-04 355
//二分查找（折半查找），版本1 int BinarySearch1(int a[], int value, int n) { int low, high, mid; low = 0; high = n-1; while(low<=high) { mid = (low+high)/2; if(a[mid]==value) return mid;
c++怎么通过结构体中指定成员查找元素
学无止尽，谨言慎行！
01-04 975
在C++中，如果你有一个包含结构体的，并且你想查找其中某个具有特定属性的结构体元素，算法同样可以使用，但你需要提供一个自定义的比较函数或谓词（predicate）来匹配结构体元素。这是因为默认使用运算符来比较元素，而结构体通常需要自定义运算符才能正确比较。不过，更常见的是使用算法，它接受一个谓词作为参数，这个谓词可以对每个元素执行自定义的比较逻辑。以下是一个示例，展示了如何使用在包含结构体的中查找具有特定属性的元素： 代码说明： 定义结构体：结构体包含和两个成员。自定义谓词（可选）：虽然在这个例子中我们
C/C++ 查找算法
yonpiguxiao的博客
12-14 1104
如果arr[mid] < x, min = mid + 1;如果arr[mid] > x, max = mid - 1;如果arr[mid] == x, 找到结果终止条件:min >= max。
数据结构 折半查找 c++
weixin_44223180的博客
07-03 1226
折半查找的实现 要求： 1.若查找成功，返回元素在有序数组中的位置和查找次数； 2.若查找失败，返回出错标志和查找次数。 //low应从0开始，因为设置的数组下标从0开始 //虽然mid不变，但是当key为首元素时，mid为1也就是第二元素，导致找不到第一个元素。 #include <iostream> using namespace std; typedef int Status; typedef int KeyType; typedef int InfoType; typedef struc
C++数据结构-顺序查找算法
weixin_43323201的博客
12-08 1981
#include &amp;lt;iostream&amp;gt; #define N 10 using namespace std; typedef struct { int *elem; int length; }SSTable; //顺序查找1 int SSearch1(SSTable &amp;amp;s , int k) //k是要查找的值 { for(int i=1;i&amp;lt;=N...
C++ 数据结构（二）向量（6）斐波那契查找
Oscaner
12-08 439
来源：我的博客站 OceanicKang |《C++ 数据结构（二）向量（6）斐波那契查找》
C++标准库实现文本查询
最新发布
金色的省略号
02-16 1054
文本查询要求： 在一个给定的文件中查询单词，查询结果：是单词在文件中出现的次数，以及其所在行的列表。如果一个单词在一行中出现多次，此行只列出一次。行按升序输出。 在C++primer第五版，第十二章 动态内存，第三节给出了实现文本查询的代码，程序设计：TextQuery类读取文件并存储文件（数据成员存储文件，存储每个单词所在的行），查询并以返回一个QureyResult类对象的方式返回查询结果（QureryResult类的数据成员以shared_ptr方式与TextQuery类共享数据），另函
C++实现常见的查找算法
热门推荐
进击的程序员
07-03 1万+
查找也称检索，是根据给定的某个值，在查找表中确定一个其关键字等于给定值的记录或数据元素。若表中存在一个这样的记录，则称查找成功，反之查找失败。 查找算法大致可以分为：   1) 顺序查找，二分查找，分块查找   2) 树型查找   3) Hash表查找 以如下数组为例： 1. 顺序查找，二分查找，分块查找     1.1 顺序查找(也叫线性查找)，在一个已知无(或有序）序队列中找
C/C++查找大总结
Juinjonn的博客
03-03 1071
定义：对已经建好散列表的数据进行查找。 >哈希是**查找速度最快**的算法。 >**缺点:**空间消耗非常大。
c/c++语言库函数查询方法（详解）
weixin_51503720的博客
07-29 8761
话不多说，步入正题： 我们参照文档，来学习几个库函数；（教会你怎么使用文档来学习库函数）。 strcpy char * strcpy(char * destination, const char * source); memset void * memset ( void * ptr, int value, size_t num); 这里对新接触c语言的同学我们推荐一个查库函数比较好用的网站点击这里。 打开网站我们查找输入我们向了解的函数，拿我们上边的strcpy来举例子吧。 .
c++的查找算法总结
luosuss的博客
12-03 2015
如果找到相邻的一对元素满足条件，则返回指向第一个相邻元素的迭代器；算法函数用于在指定范围内查找相邻的两个元素，满足指定的条件。算法函数用于在有序范围内进行二分查找，判断指定的值是否存在。算法用于在有序范围内进行二分查找，判断指定的值是否存在。算法用于在指定范围内查找相邻的两个元素，满足指定的条件。算法函数用于计算指定值在指定范围内出现的次数。算法用于计算指定值在指定范围内出现的次数。内查找第一对相邻的元素，满足相等的条件。如果不存在指定值，则返回。返回等于指定值的元素个数。如果存在指定值，则返回。
C++——常用查找算法
m0_74822436的博客
01-06 1566
统计自定义数据类型时候，需要配合重载 operator==
【C++】常用查找算法
debug...
08-06 2738
C++常用查找算法
C++文本查询程序(智能指针)
ylh的博客
08-17 854
我们需要在TextQuery类中读取数据，在TextResult类中打印数据。，如果一个单词在一行出现多次，则只记录一次，行会按照升序输出。在一个指定的文件中查询单词，查询结果是单词在。
C++查看Class类结构
doubleintfloat的博客
11-02 222
C++ cl 命令查看类内存结构
常见数据结构c++模板
dearzcs的博客
03-31 1893
数据结构C++模板
C++ find查找结构体数组中的对象方法
玫瑰花店的博客
06-22 1674
C++中通过find方法查找结构体数组中的对象
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值