C++实现二叉搜索树（Key模型和Key/value模型）

最新推荐文章于 2024-03-18 07:38:52 发布
最新推荐文章于 2024-03-18 07:38:52 发布
阅读量373 收藏
点赞数 1
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58666778/article/details/124871980
版权 
#pragma once
#include<iostream>
namespace K
{
	template<class K>
	struct BSTreeNode
	{
		BSTreeNode(const K& key)
		:left(nullptr)
		, right(nullptr)
		, _key(key)
		{}

		BSTreeNode<K>* left;
		BSTreeNode<K>* right;
		K _key;
	};

	template<class K>
	struct BSTree
	{

		typedef BSTreeNode<K> Node;

	public:
		BSTree()
			:_root(nullptr)
		{}


		//插入
		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				parent = cur;
				if (cur->_key > key)
				{
					cur = cur->left;
				}
				else if (cur->_key < key)
				{
					cur = cur->right;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key);
			if (parent->_key > key)
			{
				parent->left = cur;
			}
			else
			{
				parent->right = cur;
			}
			return true;
		}


		//删除
		bool Earse(const K& key)
		{
			//1.找到要删的节点
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->right;
				}
				else
				{
					//找到了，进行删除。	
					//（1）有一个字节点或者没有子节点
					if (cur->left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->right;
							return true;
						}

						Node* child = cur->right;
						if (parent->left == cur)
						{
							parent->left = child;
						}
						else
						{
							parent->right = child;
						}

						//记住一定要delete掉cur这个节点
						delete cur;
					}
					else if (cur->right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->left;
							return true;
						}

						Node* child = cur->left;
						if (parent->left == cur)
						{
							parent->left = child;
						}
						else
						{
							parent->right = child;
						}
						//记住一定要delete掉cur这个节点
						delete cur;
					}
					//(2)左孩子右孩子都有
					else
					{
						//1.先找到右子树的最小节点或者左子树的最大节点
						//（我这里找的是右子树的最小节点）
						//必须要有父亲才能删除
						Node* Min_parent = cur;
						Node* Min_right = cur->right;
						while (Min_right->left)
						{
							Min_parent = Min_right;
							Min_right = Min_right->left;
						}

						//2.进行替换
						cur->_key = Min_right->_key;

						//3.删除被替换的节点（一定是叶子节点或者只有一个子节点的节点)
						//为什么要判断呢？
						//因为有可能Min_Parent就是cur
						if (Min_parent->left == Min_right)
						{
							Min_parent->left = Min_right->right;
						}
						else
						{
							Min_parent->right = Min_right->right;
						}
						delete Min_right;
					}

					return true;
				}
			}
			//没有这个值，删除失败
			return false;
		}

		//中序遍历,为什么写一个子程序？
		//因为外面调用不到private的_root
		void InOrder()
		{
			_InOrder(_root);
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->left);
			cout << root->_key << " ";
			_InOrder(root->right);
		}

		//查找
		bool Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key == key)
				{
					return true;
				}
				else if (cur->_key > key)
				{
					cur = cur->left;
				}
				else
				{
					cur = cur->right;
				}
			}
			return false;
		}

		//递归版本
		//设置子函数的原因还有一样，外界无法访问到_root

		//1.插入
		bool InsertR(const K& key)
		{
			_InsertR(key, _root);
			return true;
		}

		//这里的引用用的很巧妙。
		//因为这里的root就是这棵树的节点，遇到空了就是可以进行插入了
		//直接进行new就完成了插入操作。
		bool _InsertR(const K& key, Node*& root)
		{
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}

			if (root->_key > key)
			{
				return _InsertR(key, root->left);
			}
			else if (root->_key < key)
			{
				return _InsertR(key, root->right);
			}
			else
			{
				return false;
			}


		}

		//2.查找
		Node* FindR(const K& key)
		{
			return _FindR(key, _root);
		}

		Node* _FindR(const K& key, Node* root)
		{
			if (key == root->_key || key == nullptr)
			{
				return root;
			}

			if (root->_key > key)
			{
				_FindR(key, root->left);
			}

			if (root->_key < key)
			{
				_FindR(key, root->right);
			}
		}


		//3.删除
		bool EarseR(const K& key)
		{
			return _EarseR(key, _root);
		}

		//这里的参数也是引用很巧妙
		bool _EarseR(const K& key, Node*& root)
		{
			if (root == nullptr)
			{
				return false;
			}

			//先找到要删除的节点
			if (root->_key > key)
			{
				_EarseR(key, root->left);
			}
			else if (root->_key < key)
			{
				_EarseR(key, root->right);
			}
			else
			{
				//进行删除
				//先记录要删除的节点
				Node* del = root;
				if (root->left == nullptr)
				{
					//很巧妙，直接将root换成了另外一个不为空或者可能为空的子树。
					root = root->right;
					delete del;
				}
				else if (root->right == nullptr)
				{
					root = root->left;
					delete del;
				}

				//要删除节点的有两个的时候
				else
				{
					//
					Node* min_right = root->right;
					while (min_right->left)
					{
						min_right = min_right->left;
					}

					//交换两个节点的的值
					swap(root->_key, min_right->_key);

					//当交换之后，整颗树就不是二叉搜索树了，
					//所以我们要在这个节点的右节点去删除这个值的节点就是很巧妙
					_EarseR(key, root->right);

				}
			}
		}


	private:
		Node* _root;

	};


	void TestBSTree()
	{
		BSTree<int> b;
		int a[] = { 5, 3, 6, 2, 4, 7 };
		for (auto e : a)
		{
			b.InsertR(e);
		}

		b.EarseR(7);

		b.InOrder();

	}
}

namespace KV
{

	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode(const K& key, const V& value)
		:left(nullptr)
		, right(nullptr)
		, _key(key)
		, _value(value)
		{}

		BSTreeNode<K, V>* left;
		BSTreeNode<K, V>* right;
		K _key;
		V _value;
	};

	template<class K, class V>
	struct BSTree
	{

		typedef BSTreeNode<K, V>  Node;

	public:
		BSTree()
			:_root(nullptr)
		{}


		//插入
		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				parent = cur;
				if (cur->_key > key)
				{
					cur = cur->left;
				}
				else if (cur->_key < key)
				{
					cur = cur->right;
				}
				else
				{
					return false;
				}
			}
			cur = new Node(key, value);
			if (parent->_key > key)
			{
				parent->left = cur;
			}
			else
			{
				parent->right = cur;
			}
			return true;
		}


		//删除
		bool Earse(const K& key)
		{
			//1.找到要删的节点
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->right;
				}
				else
				{
					//找到了，进行删除。	
					//（1）有一个字节点或者没有子节点
					if (cur->left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->right;
							return true;
						}

						Node* child = cur->right;
						if (parent->left == cur)
						{
							parent->left = child;
						}
						else
						{
							parent->right = child;
						}

						//记住一定要delete掉cur这个节点
						delete cur;
					}
					else if (cur->right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->left;
							return true;
						}

						Node* child = cur->left;
						if (parent->left == cur)
						{
							parent->left = child;
						}
						else
						{
							parent->right = child;
						}
						//记住一定要delete掉cur这个节点
						delete cur;
					}
					//(2)左孩子右孩子都有
					else
					{
						//1.先找到右子树的最小节点或者左子树的最大节点
						//（我这里找的是右子树的最小节点）
						//必须要有父亲才能删除
						Node* Min_parent = cur;
						Node* Min_right = cur->right;
						while (Min_right->left)
						{
							Min_parent = Min_right;
							Min_right = Min_right->left;
						}

						//2.进行替换
						cur->_key = Min_right->_key;
						cur->_value = Min_right->_value;

						//3.删除被替换的节点（一定是叶子节点或者只有一个子节点的节点)
						//为什么要判断呢？
						//因为有可能Min_Parent就是cur
						if (Min_parent->left == Min_right)
						{
							Min_parent->left = Min_right->right;
						}
						else
						{
							Min_parent->right = Min_right->right;
						}
						delete Min_right;
					}

					return true;
				}
			}
			//没有这个值，删除失败
			return false;
		}

		//中序遍历,为什么写一个子程序？
		//因为外面调用不到private的_root
		void InOrder()
		{
			_InOrder(_root);
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->left);
			cout << root->_key << ":";
			cout << root->_value << endl;
			_InOrder(root->right);
		}

		//查找
		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key == key)
				{
					return cur;
				}
				else if (cur->_key > key)
				{
					cur = cur->left;
				}
				else
				{
					cur = cur->right;
				}
			}
			return nullptr;
		}

	private:
		Node* _root;
	};

	//KV使用场景1：查找
	void TestBSTree1()
	{
		BSTree<string, string> dict;
		dict.Insert("left", "左");
		dict.Insert("right", "右");
		dict.Insert("sort", "排序");
		dict.Insert("map", "地图，映射");

		string str;
		
		while (cin >> str)
		{
			auto ret = dict.Find(str);
			if (ret)
			{
				cout << "对应中文解释是：" << ret->_value << endl;
			}
			else
			{
				cout << "查不到" << endl;
			}
		}
	}
	
	//KV使用场景2：统计次数
	void TestBSTree2()
	{
		string arr[] = { "苹果", "苹果", "苹果", "苹果", "苹果", "草莓", "草莓", "草莓", "香蕉" };
		BSTree<string, int> count_tree;
		for (auto& str : arr)
		{
			//BSTreeNode<string, int>* ret = count_tree.Find(str);
			auto ret = count_tree.Find(str);
			if (ret)
			{
				ret->_value++;
			}
			else
			{
				count_tree.Insert(str, 1);
			}
		}

		count_tree.InOrder();
	}

}
zhzhyyds
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
中级C++：二叉搜索树、key-Value模型
FamerSaul的博客
06-20 595
二叉搜索树特征和key-Value 模型的添加，遍历，搜索，删除；简单字典，统计单词（字符串）出现次数。
C++进阶—二叉搜索树Key、Key-Value模型应用及二叉树OJ（非递归实现遍历）
IfYouHave的博客
06-27 273
该种方式在现实生活中非常常见： 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英 文单词与其对应的中文就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出 现次数就是就构成一种键值对。比如：给一个单词word，判断该单词是否拼写正确，具体方式如下： 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
[C++]深入理解C++ 17 结构化绑定[key, value] 的处理
FL1768317420的博客
03-18 1103
在探索结构化绑定（Structured Bindings）的世界之前，让我们先沉思一下计算机科学家Edsger W. Dijkstra的名言：“简单性是成功的关键。” C++17标准引入的结构化绑定，正是这一理念的体现，它为我们提供了一种更简单、更直观的方式来操作复合数据类型。结构化绑定，中文可以称之为“结构化解构”或“结构绑定”，是一种新的语法结构，允许你同时从元组、结构体、数组等数据结构中提取多个变量。在C++之前的版本中，如果你想从一个元组中提取值，通常需要使用。
C++搜索二叉树(及key/value模型的应用）
分享学习的知识，记录我的技术成长道路
05-24 538
了解搜索二叉树是为了STL中的map和set做铺垫，我们所熟知的AVL树和平衡搜索二叉树也需要搜索二叉树的基础，本文就来建立一棵搜索二叉树。
C++（十三）— map的排序
dbsggal90047018的博客
08-14 273
　　在c++中有两个关联容器，第一种是map，内部是按照key排序的，第二种是unordered_map，容器内部是无序的，使用hash组织内容的。 1、对有序map中的key排序 　　如果在有序的map中，key是int，或者string，它们天然就能比较大小，本身的就是有序的。不用额外的操作。 #include<iostream> #include<al...
C++键值对
weixin_43623488的博客
10-12 1814
键值对（Key-Value Pair）是一种数据结构，用于存储和表示两个相关联的值。在键值对中，一个值被关联到一个唯一的键上，通过键可以快速地访问和获取对应的值。键值对的作用是提供一种便捷的方式来组织和存储数据。它可以用于多种场景，例如：数据存储和检索：键值对可以用于存储和检索数据，其中键可以作为数据的唯一标识，值则是与该键相关联的数据。通过键，可以快速地定位和获取对应的值。配置和参数设置：键值对可以用于存储配置信息或参数设置，其中键可以表示配置或参数的名称，值则是对应的配置值或参数值。
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
c++实现在二叉检索树中删除一个结点的算法
06-23
设计一个算法程序，使得该程序从二叉检索树中删除一个结点，并仍然保持二叉检索树的特性不变 实验要求: 创建一棵二叉检索树，然后用中序遍历查找要删除的结点的后继结点
C++ STL中Map的按Key排序和按Value排序
bigchen
09-23 894
       map是用来存放<key, value>键值对的数据结构，可以很方便快速的根据key查到相应的value。假如存储学生和其成绩（假定不存在重名，当然可以对重名加以区分），我们用map来进行存储就是个不错的选择。 我们这样定义，map<string, int>，其中学生姓名用string类型，作为Key；该学生的成绩用int类型，作为value。这...
C++读取INI文件中指定Section下的所有key和keyvalue存放到map中
09-05
C++读取INI文件中指定Section下的所有key和keyvalue存放到map中
C++之二叉树进阶|搜索树|key/value模型
choice~的博客
09-03 699
> 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: > > - 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 > - 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 > - 它的左右子树也分别为二叉搜索树
搜索二叉树——key/value模型
h1091068389的博客
05-24 452
KV模型搜索二叉树KV模型KV模型实现基本框架插入查找遍历删除测试代码 KV模型 和上一篇博客中介绍的key模型的搜索二叉树不同，KV模型的搜索二叉树对于每一个key值都有与之对应的唯一的value值，即key，value是配对出现的。这种做法在生活中也有类似的应用，例如：查找中英文字典时候，单词和其中文翻译就构成一种成对的结构。再比如统计某些情况单词字符的出现次数，也可以使用该模型。 KV模型实现 基本框架 template<class K, class V> struct BSTreeN
搜索二叉树（Key-Value）
m0_58396602的博客
04-27 978
搜索二叉树保证了对于每个根节点，左子树上所有节点值小于根节点，右子树上，所有节点的值大于根节点。由此性质保证了二叉搜索树高效的查找效率，一棵优秀的二叉搜索树可达到搜索效率log(N)的级别，但搜索二叉树如果在创建时是以有序插入，那么它会退化为单链表,搜索二叉树的性质决定了其先序遍历结果一定是按照Key递增顺序。 节点结构如下 template<class K,class V> class SBTreeNode{ public: SBTreeNode():left(nullpt
哈希表、二叉搜索树key和key value（判断是否存在、字典.....）
sophia__yu的博客
05-13 1976
key：可以判断一个单词是否拼写错误，判断网名是否存在等等； key value:实现中英文字典，统计单词出现次数等等；key value 需要在结构体中在存一个值value（中文、出现次数） 代码如下： BinarySearchTree.h #pragma once //利用二叉搜索树 key value:中英文翻译 typedef char* BSTKeyType; typede...
二叉搜索树的实现与常见用法
weixin_33928467的博客
10-23 120
作者按：因为教程所示图片使用的是 github 仓库图片，网速过慢的朋友请移步《二叉搜索树的实现与常见用法》原文地址。更欢迎来我的小站看更多原创内容：godbmw.com，进行“姿势”交流 ♪(^∇^*) 1. 为什么需要二叉搜索树？ 选择数据结构的核心在于解决问题，而不是为了使用而使用。 由于二叉搜索树的定义和特性，它可以高效解决以下问...
二叉查找树
希望和大家多多交流技术！
03-31 145
一、二叉树定义： 二叉树就是度不超过2的树（即每个节点最多有两个子结点） 满二叉树定义： 一个二叉树，每一层的结点树都达到了最大值，就称为满二叉树 二、二叉查找树API设计： 二叉查找树每个结点都是储存一个key和一个value。 本文用链表实现二叉查找树 三、二叉查找树的实现 接口Comparable<T>的使用： 注意程序这里要写上Key继承了Comparable接口，然后后面才可以调用compareTo方法 ...
搜索二叉树-key模型
h1091068389的博客
05-23 247
搜索二叉树搜索二叉树概念实现搜索二叉树构成插入中序遍历查找删除 搜索二叉树概念 搜索二叉树作为一种树型结构，他和普通二叉树有如下几种区别： 搜索二叉树的左子树，如果不为空的情况下，左子树上面所有节点的值都小于根节点 搜索二叉树的右子树，如果不为空的情况下，右子树上面所有节点的值都大于根节点 这个性质可以适用于该搜索二叉树的任意节点。 这样看来对于一个搜索二叉树的中序遍历，即可实现从小到大遍历该二叉树中的所有节点 实现搜索二叉树 构成 搜索二叉树节点的结构体和正常二叉树相同，都是由左右节点指针和其中存放的ke
你能用C++写一个由平衡因子实现二叉搜索树的代码吗
09-02
平衡二叉搜索树，即 AVL 树，是一种自平衡的二叉搜索树，它可以保证在最坏情况下的查询、插入和删除操作的时间复杂度为 O(log n)。 以下是一个用 C 语言实现 AVL 树的简单代码示例： ```c #include #include ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值