中级C++：二叉搜索树、key-Value模型

原创 已于 2022-10-12 20:59:37 修改 · 819 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c++
于 2022-06-20 18:09:29 首次发布

文章目录

二叉搜索树的特征

  • 左子树永远比根节点小，右子树永远比根节点大
  • 也是key模型，看某个数据在不在集合里面。

在这里插入图片描述

搜索树的添加

  • key值比根值大，往右边插入，小，往左边插入
  • key值和根节点值比较，确定插入在根节点的左边还是右边，根节点一定是某个叶子结点。
  • 比如插入 4，一定是在3的右边
  • 下面的x 当作key
template<class K>
struct bstn
{
	bstn()
	{
		cout << "单个链表结点的声明初始化" << endl;
	}
	bstn(const K& x)
		:_left(nullptr)
		, _right(nullptr)
		, _value(x)
	{

	}
	bstn* _left;
	bstn* _right;
	K _value;
};

template<class K>
bool bst<K>::Insert(const K& x)
{
	return bst<K>::_Insert(x);
}

template<class K>
bool bst<K>::_Insert(const K& x)
{
	if (_root==nullptr)/ /空树的处理
	{
		_root = new Node(x);/ /调用自定义类型并用x初始化
		return true;
	}
	
	Node* parent = nullptr;/ /防止走到空找不到根节点
	Node* cur = _root;
	while (cur)
	{
		/ /比右边大，就去右子树的右边插入，
		if (x>cur->_value)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if(x<cur->_value)  / /，比根值 小去左边插入
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
			/ /这个版本的搜索二叉树不支持值相等
		}

	}
	//一定比叶子节点值 大或小 进行连接插入
	cur = new Node(x);          /new会调用自定义类型的构造函数初始化
	if (parent->_value < cur->_value)  /判断插入在根的左边还是右边
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

搜索树的遍历打印

  • 仿佛是二叉树的中序遍历，排出来就是升序。
template<class K>
bool bst<K>::Ergodic()
{
	return _Ergodic(_root);
}
template<class K>
bool bst<K>::_Ergodic(Node* root)
{
/视为一个满二叉树进行遍历，找到我左为空返回，根，右子树为空返回，在返回上一层；以此类推

	if (root == nullptr)
	{
		return false;
	}
	_Ergodic(root->_left);
	cout << root->_value << " ";
	_Ergodic(root->_right);
}

搜索树的查找

  • key值比根值大，往右边找；比根值小，往左边找，比如说找：8
    在这里插入图片描述
Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}
Node* _Find(const K& x)
	{
		Node* cur = _root;
		while (cur)
		{
			if (x>cur->_value)
			{
				cur = cur->_right;
			}
			else if(x<cur->_value)
			{
				cur = cur->_left;
			}
			else
			{
				/ /不小于左边，不大于右边
				return cur;
			}
		}
		return nullptr;
	}

搜索二叉树的删除

  • 先找到那个值：key值比根值大，往右边找；比根值小，往左边找，
  • 找到以后两种情况：
    1. （key值）结点的一侧为空 ，父结点连接上不为空的一侧，删除（key值）结点；5，6，8.删除5
    2. （key值）结点的两侧都不为空：找（key值）左右两边的最值替换：找左边最大的或右边最小的替换。
    3. 往根的左边走一步，如果右边不为空，然后持续往右走；最大值的右子树必然是空，往右找到空，记录父节点，然后删除最大值节点。
    4. 比如删除 2
      在这里插入图片描述
bool Erase(const K& key)
	{
		return _Erase(_root, key);
	}
template<class K>
bool bst<K>::_Erase(const K& x)  /  /x  ---》  key
{
	
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_value < x)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if(cur->_value>x)
		{
			parent = cur;
			cur = cur->_left;
		}
		else  / /上面走完之后 此处 值相等 找到
		{
			/ /左子树或右子树为空，双亲结点连接上孩子结点不为空的一侧，删除key值节点
			if (cur->_left == nullptr)//如果cur左边为空，右边不为空
			{
				if (_root == cur)//只有一个结点或单条边为空。
				{
					_root = cur->_right;
				}
				else
				{
					if (cur = parent->_left)//cur是双亲结点的左边
					{
						//则链接cur的右边
						parent->_left = cur->_right;
					}
					else  //是双亲结点的右边 且左边为空
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (_root == cur)//只有一个结点或单条边为空。
				{
					_root = cur->_left;
				}
				else
				{
					if (cur = parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else  / /两边都不为空   左边的最大值节点和 key节点交换值 ，   删除最大值节点
			{

				Node* maxLeft = cur->_left;
				Node* pmax = cur;
				while (maxLeft->_right)   / /不为空就往右边走  一个值记录最值的父节点
				{
					pmax = maxLeft;
					maxLeft = maxLeft->_right;
				}
				cur->_value = maxLeft->_value;
				if (pmax->_right=maxLeft)  / /此时最大值节点的右边为空，左边还可能有子树比它小的
				{
					pmax->_right = maxLeft->_left;/ / 判断最大值节点是父结点的哪一边
				}
				else   / /让父节点接上最大值节点的左子树
				{
					pmax->_left = maxLeft->_left;
				}
				delete maxLeft;
			}
			return true;   / /删除完成返回
		}
	}
	return false;  / /走到空说明没有那个值
}

递归版本

  • 贵在每一次递归进来就是对根节点子树的引用。

递归插入

  • 插入10
    在这里插入图片描述

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
	
template<class K>
bool bst<K>::_InsertR(Node*& root, const K& key)
{
	if (root==nullptr)   / /是对8右指针的引用
	{
		root = new Node(key);  / / 8->right = .....接上即可
		return true;
	}
	else
	{
		if (root->_value < key)
			return _InsertR(root->_right, key);
		else if (root->_value > key)
			return _InsertR(root->_left, key);
		else
			return false;
	}
}

递归查找

  • 比如查找：3
    在这里插入图片描述
Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}

template<class K>
bst<K>::Node* bst<K>::_FindR(Node*& root,const K& key)  / /3
{
	if (root == nullptr)   / /2的右子树引用  3
	{
		return nullptr;
	}
	if (root->_value < key)                       / /2   
		return _FindR(root->_right, key);      / /不大
	else if (root->_value > key)  / / 5   2      / /不小
		return _FindR(root->_left, key);
	else
		return root;    / /相等返回  秒啊
}

递归删除

  • 比如删除：2
    在这里插入图片描述
    在这里插入图片描述
bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
template<class K>
bool bst<K>::_EraseR(Node*& root,const K& key)
{
	if (root == nullptr)
	{
		return false;
	}
	if (root->_value<key)
	{
		return _EraseR(root->_right, key);
	}
	else if (root->_value>key)  //5 > 2  
	{
		return _EraseR(root->_left, key);  //ture   返回....
	}
	else
	{
		Node* del = root;   //root 是 对2的引用  也是2这个节点
		if (root->_left == nullptr)
		{
			root == root->_right;		// 5的left 链接到key值不为空的一侧
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;  	//最后删除del
		}
		else  / / 有  1  3
		{
			Node* maxLeft = root->_left;  	//root 还是2 
			while (maxLeft->_right) 		// 左孩子节点的右子树为空则  说明左孩子的值就是最大值
			{
				maxLeft = maxLeft->_right;
			}
			root->_value = maxLeft->_value;		//替换

			return _Erase(root->_left,maxLeft->key);  //再递归删除 最大值节点 
			// 2的左边引用     1 相等 ； 1的节点交给 del ；1的左边为空，  2左边的引用 链接到引用的右边；删除 del ，返回。
		}
		delete del;
		return true;
	}
}

接口总览

template<class K>
class bst
{
public:
	typedef bstn<K>  Node;
	bst()
	{
		cout << "搜索二叉树的节点" << endl;
	}
	bool Insert(const K& x);
	bool Ergodic();
	Node* Find(const K& x)
	{
		return _Find(x);
	}
	bool Erase(const K& x)
	{
		return _Erase(x);
	}
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	bool _Insert(const K& x);/ /隐藏实现细节
	bool _Ergodic(Node* root);
	bool _Erase(const K& x);
	Node* _Find(const K& x)
	{
		Node* cur = _root;
		while (cur)
		{
			if (x>cur->_value)
			{
				cur = cur->_right;
			}
			else if(x<cur->_value)
			{
				cur = cur->_left;
			}
			else
			{
				/ /不小于左边，不大于右边
				return cur;
			}
		}
		return nullptr;
	}

	bool _InsertR(Node*& root,const K& key);
	Node* _FindR(Node*& root,const K& key);
	bool _EraseR(Node*& root,const K& key);

	Node* _root;
};

key-Value 模型

  • 场景：字典翻译，统计单词出现的次数； 刷身份证进站。
  • 是对Key模型的改造：
    • 添加一个V模板参数即可，添加时多添加一个参数
    • 找到Key就能删除Value

基建

namespace KEY_VALUE
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;

		BSTreeNode(const K& key, const V& value)
			: _left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
	.....
	private:
	Node* _root = nullptr;
	}

key-Value的添加

bool _InsertR(Node*& root, const K& key, const V& value)
{
	if (root==nullptr)  
	{
		root = new Node(key,value);  
		return true;
	}
	else
	{
		if (root->_key < key)
			return _InsertR(root->_right, key);
		else if (root->_key > key)
			return _InsertR(root->_left, key);
		else
			return false;
	}
}

key-Value的遍历打印

bool _Ergodic(Node* root)
{
	if (root == nullptr)
	{
		return false;
	}
	_Ergodic(root->_left);
	cout << root->_key << " "<<root->_value<<endl;
	_Ergodic(root->_right);
}

key-Value的查找

Node* _FindR(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key>cur->_key)
			{
				cur = cur->_right;
			}
			else if(key<cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				//不小于左边，不大于右边
				return cur;
			}
		}
		return nullptr;
	}

key-Value的删除

bool _EraseR(Node*& root,const K& key)
{
	if (root == nullptr)
	{
		return false;
	}
	if (root->_key<key)
	{
		return _EraseR(root->_right, key);
	}
	else if (root->_key>key) 
	{
		return _EraseR(root->_left, key);  
	}
	else
	{
		Node* del = root;  
		if (root->_left == nullptr)
		{
			root == root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;  
		}
		else  
		{
			Node* maxLeft = root->_left;  
			while (maxLeft->_right) 
			{
				maxLeft = maxLeft->_right;
			}
			root->_key = maxLeft->_key;		//替换
			root->_value =maxLeft->_value;

			return _Erase(root->_left,maxLeft->_key);  //再递归删除 最大值节点 
		}
		delete del;
		return true;
	}
}

简单字典

void TestDict()
{
	KEY_VALUE::BSTree<string, string> dict;
	dict.InsertR("crash", "崩溃");
	dict.InsertR("priority", "优先级");
	string str;
	while (cin >> str)
	{
		if (str == "Q")//quit 退出
		{
			break;
		}
		else
		{
			auto ret = dict.FindR(str);  //返回的是个结构体指针Node*
			if (ret == nullptr)
			{
				cout << "This word is not available in the dictionary, please re-enter it" << endl;
			}
			else
			{
				cout << ret->_key << "->" << ret->_value << endl;
			}
		}
	}
}

统计单词（字符串）出现次数

void TestCWord()
{
	string str[] = { "i","dont","have","a","dream","when","i","was","a","child" };
	KEY_VALUE::BSTree<string, int> countree;
	for (auto& i : str)
	{
		auto ret = countree._FindR(i);
		if (ret==nullptr)
		{
			countree._InsertR(i, 1);	//没有则进行插入，次数是第一次
		}
		else
		{
			ret->_value++;		//有则 int value ++
		}
	}
	countree._Ergodic();
}

结束

  • 按时吃饭，不要熬夜，太累了就睡觉…
    在这里插入图片描述
C++ STL容器Map的按Key排序和按Value排序
qq_41896736的博客
09-07 2053
1、按Key排序 我们知道，map内部本身就是按序存储的（红黑树），在我们插入<key, value>键值对时，就会按照key的大小顺序进行存储。这也是作为key的类型必须能够进行<运算比较的原因。现在我们用string类型作为key，因此，我们的存储就是按string的字典排序储存的。 #include <map> #include <string> #include <iostream> using namespace std; int main(
深入理解 Key-Value 存储：架构设计与实际应用
最新发布
m0_53716766的博客
09-13 1934
本文系统介绍了Key-Value存储的核心概念与应用。Key-Value存储作为一种高性能的NoSQL数据模型，通过键值对实现快速数据存取，相比关系型数据库具有模型简单、扩展性强等优势。文章详细分析了KV存储的特点、适用场景（如缓存、会话管理等）及主流产品（Redis、Memcached等），并通过银行系统实例演示了KV存储的实际应用。同时，文章深入探讨了网络编程框架（io_uring、ntyco、reactor）的性能特点及选择建议，并基于OSI七层模型解析了Web服务器与网络框架的协同工作机制，为开发者
[Key-Value 存储系统全解析]
stjklkjhgffxw的博客
09-12 1171
Key-Value 存储系统是一种基于键值对的 NoSQL 数据库。与传统的关系型数据库不同,它没有固定的模式,数据以键值对的形式存储和检索。这种灵活性使得 Key-Value 存储系统非常适合存储和处理半结构化或非结构化数据,如日志、会话信息、用户配置文件等。键(Key): 用于唯一标识数据的字符串或二进制值。值(Value): 与键关联的数据,可以是任何类型的信息,如字符串、对象、文件等。存储(Store): 用于存储和检索键值对的系统或服务。
C++ map通过key获取value
热门推荐
liaosongmao1的专栏
12-19 6万+
c++的map中通过key获取value的方法 一般是value  =map[key]，或者另一种迭代器的方式 1、在map中，由key查找value时，首先要判断map中是否包含key。 2、如果不检查，直接返回map[key]，可能会出现意想不到的行为。如果map包含key，没有问题，如果map不包含key，使用下标有一个危险的副作用，会在map中插入一个key的元素，value
C++之生成key-value键值三种方式(一百九十)
Android系统攻城狮
09-08 629
本篇目的：理解C++之三种键值生成方式。
【C++】key 的单身日记 vs key/value 的完美搭档
2401_83431652的博客
09-28 1198
本文介绍了关联式容器和二叉搜索树的核心概念与实现。关联式容器（如set、map及其衍生体）基于红黑树实现，通过键值自动排序元素，不支持序列式操作。二叉搜索树的实现包括插入、查找和删除操作，其中删除操作根据节点子节点情况分为四种处理方式。文章还区分了key-only和key-value两种应用场景，并给出了对应的C++代码实现，包括节点结构、基本操作和遍历方法。最后展示了支持key-value对的二叉搜索树完整实现，包含拷贝构造、赋值运算符等特殊成员函数。
【C++】二叉搜索树|Key模型|key_value模型|基本操作
m0_67367079的博客
06-24 1084
BST。每个节点包含一个键（key）和两个指针，分别指向其左子树和右子树。左子树上的所有节点的键值都小于其父节点的键值。右子树上的所有节点的键值都大于其父节点的键值。每个子树也是一棵二叉搜索树。每个节点包含三个部分：一个键（Key），一个值（Value），以及两个指向其子节点的指针（分别指向左子树和右子树）。
【C++进阶】探秘二叉搜索树
小羊的博客
09-18 2048
二叉搜索树的底层实现
C++：二叉搜索树
HZzzzzLu的博客
09-21 2053
一文带你理解二叉搜索树
C++搜索二叉树(及key/value模型的应用）
分享学习的知识，记录我的技术成长道路
05-24 1191
了解搜索二叉树是为了STL中的map和set做铺垫，我们所熟知的AVL树和平衡搜索二叉树也需要搜索二叉树的基础，本文就来建立一棵搜索二叉树。
412-C++中map自定义key和value排序
Edward_LF的博客
06-23 862
map默认是按key值从小到大排序的map容器里面有两个值一个key一个是value，，其实map里面还有第三个参数，是一个类，用来对map的key进行排序的类，定义如下： less的代码： 那么根据上面的代码我们也可以写出一个greater类来让key按照降序排列：注意：这里也可以不使用MyCompare 仿函数，直接用greater 将map的key和value以pair的形式装到vector中，对vector进行排序。 （下面使用unordered_map，而没有使用map） 这是从小......
C++进阶—二叉搜索树Key、Key-Value模型应用及二叉树OJ（非递归实现遍历）
IfYouHave的博客
06-27 492
该种方式在现实生活中非常常见： 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英 文单词与其对应的中文就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出 现次数就是就构成一种键值对。比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
C++类模板(以元组(key,value)为例,实例化类模板为模板类)
xuchaoxin1375的博客
10-07 759
//program 18.2.1.cpp Pair类模板 /* 类模板看上去很像-一个类。下面以Pair类模板为例来说明类模板的写法和用法。 实践中常常会碰到,某项数据记录由两部分组成,一部分是关键字key,另一部分是值value。 (关键字用来对记录进行排序和检索,根据关键字能查到值。) 例如本例子，学生Student记录由两部分组成, 一部分是学号(作为key),另一部分是绩点(作为value)。即学号就是关键字，绩点就是值。 要能根据学号对学生进行排序，以便根据学号能方便地检索到绩点, 每个学生的信
数据库索引（key-value）
HyzKey2U的博客
05-14 2858
常见的索引结构有: B 树， B+树和 Hash。但是Mysql并不采用Hash因为会有冲突，并且不利于顺序查询。比方说下列语句： SELECT * FROM tb1 WHERE id < 500; 如果没建立索引的话，主键自增只需要按顺序查找前100条元素即可，但是如果使用ID-hash索引，每次都要把ID输入到Hash中进行处理，反而慢。 B 树& B+树两者有何异同呢？ 多路查找平衡树，B 树的所有节点既存放键(key) 也存放数据(data)。B 树的叶子节点都是独立的。
C++（十三）— map的排序
dbsggal90047018的博客
08-14 405
　　在c++中有两个关联容器，第一种是map，内部是按照key排序的，第二种是unordered_map，容器内部是无序的，使用hash组织内容的。 1、对有序map中的key排序 　　如果在有序的map中，key是int，或者string，它们天然就能比较大小，本身的就是有序的。不用额外的操作。 #include<iostream> #include<al...
C++ STL中Map的按Key排序和按Value排序
bigchen
09-23 1148
       map是用来存放<key, value>键值对的数据结构，可以很方便快速的根据key查到相应的value。假如存储学生和其成绩（假定不存在重名，当然可以对重名加以区分），我们用map来进行存储就是个不错的选择。 我们这样定义，map<string, int>，其中学生姓名用string类型，作为Key；该学生的成绩用int类型，作为value。这...
C++键值对
weixin_43623488的博客
10-12 3754
键值对（Key-Value Pair）是一种数据结构，用于存储和表示两个相关联的值。在键值对中，一个值被关联到一个唯一的键上，通过键可以快速地访问和获取对应的值。键值对的作用是提供一种便捷的方式来组织和存储数据。它可以用于多种场景，例如：数据存储和检索：键值对可以用于存储和检索数据，其中键可以作为数据的唯一标识，值则是与该键相关联的数据。通过键，可以快速地定位和获取对应的值。配置和参数设置：键值对可以用于存储配置信息或参数设置，其中键可以表示配置或参数的名称，值则是对应的配置值或参数值。
Redis（key-value）数据库
Jin的随手笔记
03-23 3432
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
redis(1)-key-value-基本概念
aggie4628的专栏
03-08 1123
redis(1)-key-value-基本概念
数据库的数据结构（1）——key-value
L1kk_的博客
01-09 4388
数据库的日志系统 许多数据库内部使用日志，日志是一个只支持追加更新的记录序列的集合，通常存储了大量的数据。如果每查询一条数据要从头到位扫描整个数据文件来查找数据所在的位置，查找的开销是O(n)，并不是是十分友好。为了高效从数据库中查找到特定的值，需要新的数据结构：索引。 索引是基于原始数据派生而来的额外数据结构，许多数据库允许单独增加和删除索引，而不影响数据库的内容，只影响查询性能。维护额外的数据结构必然带来额外的写入开销。对于写入，很难超过单纯以追加文件方式的性能。 适当的索引可以加速读取查询，但每个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值