二叉搜索树

已于 2024-08-13 21:54:50 修改
阅读量400 收藏 16
点赞数 20
分类专栏： C++ 文章标签： 数据结构 算法 c++ 开发语言
于 2024-08-06 11:52:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80239034/article/details/140823162
版权

目录

搜索二叉树的概念：

搜索二叉树的操作：

插入：

查找：

删除：

搜索二叉树的实现：

Key模型：

KeyValue模型：

搜索二叉树的概念：

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

若它的左子树不为空，则左子树的值小于根结点

若它的右子树不为空，则右子树的值大于根结点

它的左右子树也分别是搜索二叉树

搜索二叉树的操作：

插入：

a. 树为空，则直接新增节点，赋值给root指针。
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点。

查找：

a. 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b. 最多查找高度次，走到到空，还没找到，这个值不存在。

删除：

首先查找元素是否在二叉搜索树中，如果不存在，则返回 , 否则要删除的结点可能分下面四种情 况：
        a. 要删除的结点无孩子结点
        b. 要删除的结点只有左孩子结点
        c. 要删除的结点只有右孩子结点
        d. 要删除的结点有左、右孩子结点
待删除节点有 4 中情况，实际情况 a 可以与情况 b 或者 c 合并起来，因此真正的删除过程如下： 情况b ：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点 -- 直接删除
情况c ：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点 -- 直接删除
情况d ：在它的右子树中寻找中序下的第一个结点 ( 关键码最小 )，用它的值填补到被删除节点
中，再来处理该结点的删除问题 -- 替换法删除

搜索二叉树的实现：

Key模型：

namespace key
{
	template <class T>
	struct BSTNode
	{
		T _data;
		BSTNode<T>* _left;
		BSTNode<T>* _right;

		BSTNode(const T& data = T())
			:_left(nullptr)
			, _right(nullptr)
			, _data(data)
		{}
	};

	template <class T>
	class BSTtree
	{
		typedef BSTNode<T> Node;
	public:

		BSTtree()
			:_root(nullptr)
		{}

		BSTtree(const BSTtree<T> & r)
		{
			_root = _Copy(r._root);
		}
		bool Insert(const T& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* pcur = _root;

			while (pcur)
			{
				if (pcur->_data < key)
				{
					parent = pcur;
					pcur = pcur->_right;
				}
				else if (pcur->_data > key)
				{
					parent = pcur;
					pcur = pcur->_left;
				}
				else
				{
					return false;
				}
			}

			pcur = new Node(key);
			if (parent->_data > key)
			{
				parent->_left = pcur;
			}
			else if (parent->_data < key)
			{
				parent->_right = pcur;
			}
			return true;
		}

		bool Find(const T& key)
		{
			Node* pcur = _root;
			while (pcur)
			{
				if (key < pcur->_data)
				{
					pcur = pcur->_left;
				}
				else if (key > pcur->_data)
				{
					pcur = pcur->_right;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

		bool Erase(const T& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 0-1个孩子的情况
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_right;
							else
								parent->_right = cur->_right;
						}

						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}

						delete cur;
						return true;
					}
					else
					{
						// 2个孩子的情况
						// 右子树的最小节点作为替代节点
						Node* rightMinP = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinP = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMinP->_left == rightMin)
							rightMinP->_left = rightMin->_right;
						else
							rightMinP->_right = rightMin->_right;

						delete rightMin;
						return true;
					}
				}
			}

			return false;
		}

		bool Inorder()
		{
			_Inorder(_root);
			return true;
		}

		~BSTtree()
		{
			_BSTtree(_root);
		}
	private:
		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			printf("%d ", root->_data);
			_Inorder(root->_right);
		}

		void _BSTtree(Node *root)
		{
			if (root == nullptr)
			{
				return;
			}
			_BSTtree(root->_left);
			_BSTtree(root->_right);
			delete root;
		}

		Node* _Copy(Node* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			Node* newroot = new Node(root->_data);
			newroot->_left = _Copy(root->_left);
			newroot->_right = _Copy(root->_right);
			return newroot;
		}

		Node* _root = nullptr;
	};
}

KeyValue模型：

namespace keyvalue
{
	template <class T,class U>
	struct BSTNode
	{
		pair<T, U> _kv;
		BSTNode<T,U>* _left;
		BSTNode<T,U>* _right;

		BSTNode(const pair<T, U>& kv = pair<T, U>())
			:_left(nullptr)
			, _right(nullptr)
			, _kv(kv)
		{}
	};

	template <class T,class U>
	class BSTtree
	{
		typedef BSTNode<T,U> Node;
	public:
		BSTtree()
			:_root(nullptr)
		{}

		bool Insert(const pair<T, U>& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* parent = nullptr;
			Node* pcur = _root;

			while (pcur)
			{
				if (pcur->_kv.first < key.first)
				{
					parent = pcur;
					pcur = pcur->_right;
				}
				else if (pcur->_kv.first > key.first)
				{
					parent = pcur;
					pcur = pcur->_left;
				}
				else
				{
					return false;
				}
			}

			pcur = new Node(key);
			if (parent->_kv.first > key.first)
			{
				parent->_left = pcur;
			}
			else if (parent->_kv.first < key.first)
			{
				parent->_right = pcur;
			}
			return true;
		}

		bool Find(const pair<T, U>& key)
		{
			Node* pcur = _root;
			while (pcur)
			{
				if (key.first < pcur->_kv.first)
				{
					pcur = pcur->_left;
				}
				else if (key.first > pcur->_kv.first)
				{
					pcur = pcur->_right;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

		bool Erase(const pair<T, U>& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_kv.first < key.first)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_kv.first > key.first)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 0-1个孩子的情况
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_right;
							else
								parent->_right = cur->_right;
						}

						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}

						delete cur;
						return true;
					}
					else
					{
						// 2个孩子的情况
						// 右子树的最小节点作为替代节点
						Node* rightMinP = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinP = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_kv.first = rightMin->_kv.first;

						if (rightMinP->_left == rightMin)
							rightMinP->_left = rightMin->_right;
						else
							rightMinP->_right = rightMin->_right;

						delete rightMin;
						return true;
					}
				}
			}

			return false;
		}

		bool Inorder()
		{
			_Inorder(_root);
			return true;
		}

		~BSTtree()
		{
			_BSTtree(_root);
			_root = nullptr;
		}

		BSTtree(const BSTtree<T, U>& b)
		{
			_root = _Copy(b._root);
		}
	private:
		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			printf("%d ", root->_kv.first);
			_Inorder(root->_right);
		}

		void _BSTtree(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_BSTtree(root->_left);
			_BSTtree(root->_right);
			delete root;
		}

		Node* _Copy(Node* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			Node* newroot = new Node(root->_kv);
			newroot->_left = _Copy(root->_left);
			newroot->_right = _Copy(root->_right);
			return newroot;
		}
		Node* _root = nullptr;
	};
}

PaPeR ..
关注
专栏目录
Remote Dictionary Server（Redis）——基于 KV 结构的作为 Cache 使用的 NoSQL 数据库管理系统
weixin_39455125的博客
06-20 850
redis
KV结构的搜索二叉树构建
qq_61932634的博客
05-15 277
又称二叉排序树，是二叉树的一种变种，抽象结构与二叉树基本相同，但又有着以下性质：若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树。简单的来说，就是，图如下：而所谓的，K是指Key，即用来比较的关键字，V是指Value，即保存的值。就如上图一样，。在存取时更加的多样化。
【数据结构】＜KV＞模型二叉搜索树实现
zhaocx111222333的博客
05-14 183
KV模型二叉搜索树： #include<iostream> using namespace std; template <class K,class V> struct BNode{ K _key; V _val; typedef BNode<K, V> Node; Node* _left; Node* _right; BNode(const K& key, const V&val) :_key(key) , _val(val)
KV结构是什么
hanbing1398的博客
11-05 2272
kv存储机制（key-value-store）是商派研发的ecos框架解决大数据存储的一种优化方式。 对memcached、systemfile/flare等进行封装把不常变动的一些数据存储在kvstore中。 举个例子：原来你想存一个字段入库，但是为了一个字段建一张表再插入、取出数据 是不是太麻烦，太铺张浪费了。有了KV， 我直接存字段到框架自身建好的表或者缓存中， 需要的时候直接凭借key拿出value就好，是不是方便多了，这就是它的奇妙之处。 ...
二叉搜索树（KV模型，二叉搜索树删除节点）
qq_45928272的博客
05-19 539
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 每个子树均满足这个特征。 他可以用来搜索，在我们以前怎么搜索呢，之前的数据结构不仅能存储数据，也能查找数据。最优搜索便是二分查找，但是二分查找前提必须有序，最快的一个排序也是n*logn，并且二分查找必须要在Vector中，头插，中间插，头删，中间删的挪动数据的复杂度也很高。他是一种
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
饿了么分布式KV架构与实践
09-11 340
本文根据赵子明老师在2018年5月12日【第九届中国数据库技术大会(DTCC)】现场演讲内容整理而成。 讲师简介： 赵子明，一个熟悉基础架构和应用架构的双料胖子，曾在大麦网、京...
spark篇之kv结构算子
weixin_48960305的博客
10-20 232
spark中的算子调用： 1.aggregateByKey算子 def main(args : Array[String]):Unit={ val conf: SparkConf = new SparkConf().setMaster("local").setAppName("aggregateByKey") val sc: SparkContext = new SparkContext(conf) val rdd: RDD[(String, Int)] = sc.makeRDD(List(("
二叉搜索树（kv模型）的模拟实现
唐学长的博客
05-26 282
二叉搜索树（kv模型）的模拟实现
搜索结构之K模型与KV模型
奥利奥恨情歌的博客
05-17 2091
搜索结构之K模型与KV模型 搜索结构 在日常的应用中，我们经常需要在海量数据中进行搜索某一数据。根据目前掌握的方法我们可以选择树形结构类似搜索树，平衡树，红黑树等搜索结构。以及哈希这种映射结构。两类结构各有优劣在这里不进行比较，详情请看以前博客。 K与YV模型 搜索结构中同时也分为不同的应用场景，比如单体映射，关键码即为需要搜索到的值，还有双映射，在关键码位置还储存一个数据。第一种...
二叉搜索树K和KV结构模拟
最新发布
m0_62792369的博客
08-13 207
二叉搜索树K和KV结构实现
【手撕STL】二叉搜索树
AI_ELF的博客
03-12 2071
这里写目录标题二叉搜索树二叉搜索树操作二叉搜索树的插入二叉搜索树的查找二叉搜索树的删除二叉搜索树的实现 二叉搜索树 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注：二叉搜索树查找一个值最多查找高度次 二叉搜索树操作 二叉搜索树的插入 a. 树为空，则直接插入 b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
KV存储的对比
热门推荐
chenglinhust的专栏
10-31 1万+
KV存储的对比 转载于：https://yq.aliyun.com/articles/85634?spm=5176.8091938.0.0.Bck5cC 最近对各种KV存储进行一个比较，从存储引擎到存储引擎的类型，到单机版的kvstore，再到分布式kvstore集群。 存储引擎的类型 类型 全称 btree
KV数据库是怎样支持SQL语句的
Likes的博客
06-03 4454
https://pingcap.com/blog-cn/tidb-internal-2/ 三篇文章了解 TiDB 技术内幕 - 说计算 关系模型到 Key-Value 模型的映射 在这我们将关系模型简单理解为 Table 和 SQL 语句，那么问题变为如何在 KV 结构上保存 Table 以及如何在 KV 结构上运行 SQL 语句。 假设我们有这样一个表的定义： Copy CREATE...
KV数据库
weixin_34149796的博客
02-25 4516
2019独角兽企业重金招聘Python工程师标准>>> ...
Apache Kylin Cube 构建原理
liuwei0376的专栏
07-21 2276
转载于：  http://blog.bcmeng.com/post/kylin-cube.html 谢谢原作者分享 作者: 康凯森 日期: 2016-10-06 分类: OLAP Apache Kylin 是什么OLAP 是什么Kylin如何实现超大数据集的秒级多维分析查询Kylin的预计算是如何实现的Cube 和 Cuboid是什么Cuboid 的维度
Java实现二叉搜索树实例教程
资源摘要信息: "tree-java.rar_tree_二叉搜索树" 在计算机科学中，二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树结构，它满足以下性质：对于树中的任意节点N，其左子树中的所有元素的值都小于节点N...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值