二叉搜索树BinarySearchTree

最新推荐文章于 2024-09-26 19:41:19 发布
最新推荐文章于 2024-09-26 19:41:19 发布
阅读量153 收藏 2
点赞数 1
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shen_11/article/details/130345996
版权
本文介绍了二叉搜索树的概念，包括其查找、插入和删除操作的详细过程。在删除操作中，讨论了不同情况的处理方法。此外，还提供了K模型和KV模型的二叉搜索树实现，以及对其性能分析，指出在最坏情况下时间复杂度可能达到O(n)。
摘要由CSDN通过智能技术生成

二叉搜索树

1.二叉搜索树的概念

二叉搜索树也叫二叉排序树，是二叉树的进阶且具有以下性质：

  • 若左子树不为空，左子树上所有节点的值都小于根节点的值
  • 若右子树不为空，右子树上所有节点的值都大于根节点的值
  • 左右子树也分别为二叉搜索树

大概就长成这样：

 

2.二叉搜索树的操作

1).二叉搜索树的查找 

查找根据性质很简单啊。

从root开始比较，比root大往右查找，比root小往左查找

最多查找高度次，走到空没找到说明没有这个值。

2).二叉搜索树的插入

插入也不难。

  • 如果root为空，直接新增节点赋值给root。
  • 如果root不为空，再按照性质找到新根应属的位置，再插入新节点

3).**二叉搜索树的删除

ok兄弟们来活了，这个删除是个重点嗷。

还是这个树，我们可以看到删除是分为多种情况的。

首先先找找要删的值是不是在这个树里，如果不存在直接false，存在就继续分情况：

  1.  要删除的是叶子节点
  2. 要删除的节点只有左孩子节点
  3. 要删除的节点只有右孩子节点
  4. 要删除的节点有俩孩子节点

在实现的时候我们可以，把叶子节点和只有一个孩子节点的情况融到一起。

ok，我们实现一下上面几个操作

3).二叉搜索树的实现

namespace key
{
	template<class K>
	struct BSTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;
		BSTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		BSTree() = default;//指定强制生成默认构造

		bool Insert(const K& key)
		{
			//为空
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;
			//非空判断
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			//cur为空 parent是最后要链接的节点
			//链接
			cur = new Node(key);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}
		
		bool Find(const K& key)
		{
			Node* cur=_root;
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

		bool Erase(const K& key)
		{
			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//找到了要删除的节点
				{
					//有一个或者没有孩子
					if (cur->_left == nullptr)//孩子在右子树
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)//孩子在左子树
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else//俩孩子（要删的是个根）,找子树中最符合的当新的根 
						//也就是左子树的最右，或者右子树的最左
					{
						//找左子树的最大
						Node* pMaxLeft = cur;
						Node* MaxLeft = cur->_left;
						while (MaxLeft->_right)
						{
							pMaxLeft = MaxLeft;
							MaxLeft = MaxLeft->_right;
						}
						//找到左子树的最大值
						cur->_key = MaxLeft->_key;
						if (pMaxLeft->_left == MaxLeft)
						{
							pMaxLeft->_left = MaxLeft->_left;
						}
						else
						{
							pMaxLeft->_right = MaxLeft->_left;
						}
						delete MaxLeft;
					}
					return true;
				}
			}
			return false;
		}
	private:
		Node* _root = nullptr;
	};
}

代码中着重讲解了Erase，值得多次理解

4).二叉树的应用

1.K模型：K模型只有key作为关键码，结构中只需要储存Key。关键码：需要搜索到的值。

一对一关系（有没有）：汉译英、打卡系统(有这个人的信息打卡成功，没有则失败）

2.KV模型：每一个关键码Key都有与之对应的Value，<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:
		BSTree() = default;//指定强制生成默认构造
		BSTree(const BSTree<K,V>& t)
		{
			_root = Copy(t._root);
		}
		BSTree<K,V>& operator=(BSTree<K,V> t)
		{
			swap(_root, t._root);
			return *this;
		}
		~BSTree()
		{
			Destroy(_root);
		}

		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)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			//cur为空 parent是最后要链接的节点
			//链接
			cur = new Node(key,value);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			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//找到了要删除的节点
				{
					//有一个或者没有孩子
					if (cur->_left == nullptr)//孩子在右子树
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)//孩子在左子树
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else//俩孩子（要删的是个根）,找子树中最符合的当新的根 
						//也就是左子树的最右，或者右子树的最左
					{
						//找左子树的最大
						Node* pMaxLeft = cur;
						Node* MaxLeft = cur->_left;
						while (MaxLeft->_right)
						{
							pMaxLeft = MaxLeft;
							MaxLeft = MaxLeft->_right;
						}
						//找到左子树的最大值
						cur->_key = MaxLeft->_key;
						if (pMaxLeft->_left == MaxLeft)
						{
							pMaxLeft->_left = MaxLeft->_left;
						}
						else
						{
							pMaxLeft->_right = MaxLeft->_left;
						}
						delete MaxLeft;
					}
					return true;
				}
			}
			return false;
		}

		//因为_InOrder要传参是_root，但是f（这里不能用_root）所以写一个函数，在内部给_InOrder传_root
		void InOrder()
		//void _InOrder(Node* root)
		{
			_InOrder(_root);
			cout << endl;
		}
		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}
		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}
		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}


	protected:
		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root == nullptr;
		}
		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;
			_InOrder(root->_left);
			cout << root->_key << " "<<root->_value<<" "<<endl;
			_InOrder(root->_right);
		}

		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key == key)
				return true;

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

		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;
			if (root->_key < key)
			{
				_EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				_EraseR(root->_left, key);
			}
			else
			{
				Node* del = root;
				//开始删除
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					//找左子树最大/右子树最小
					Node* MinRight = root->_right;
					while (MinRight->_left)
					{
						MinRight = MinRight->_left;
					}
					swap(root->_key, MinRight->_key);
					return _EraseR(root->_right, key);
				}
				delete del;
				return true;
			}
		}
	private:
		Node* _root = nullptr;
	};
}

5).二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

因为我们root的选择是根据，输入次序选择的。所以不能保证我们的二叉搜索树是均衡的。

可能出现这种情况：

 所以最好情况下时间复杂度为O(logN)，最会情况下为O(n)，总体来说他还是一个O(n)的数据结构

shen_11
关注
Binary Search Tree
04-05
Binary Search Tree 利用C++實現 Binary Search Tree
700. Search in a Binary Search Tree
学习应该是一个长链接
08-28 525
Given the root node of a binary search tree (BST) and a value. You need to find the node in the BST that the node's value equals the given value. Return the subtree rooted with that node. If such node...
BinarySearchTree
qq_49471950的博客
04-08 94
1.二叉查找树定义 BST是一棵二叉树，其中的每一个结点都含有一个Comparable的键（以及相关联的值）且每个结点的键都大于左子树中的任意结点的键和大于右子树中任意结点的键。 2.基于二叉查找树的符号表 public class BinarySearchTree<Key extends Comparable<Key>,Value> { TreeNode root = null;//保存根结点 //删除结点方法 public void delete(Key key)
二叉搜索树实例练习
09-05
`BinarySearchTree` 类是二叉搜索树本身，包含根节点的引用。`insert` 方法用于向树中插入节点，`printTree` 方法用于先序遍历并返回字符串表示。`main` 函数读取输入的序列，构建二叉搜索树，并通过比较它们的先序...
二叉搜索树的插入删除_二叉搜索树_python_
09-29
在实际使用中，你可以创建一个`BinarySearchTree`实例，然后通过调用`insert`和`delete`方法来操作二叉搜索树。例如： ```python bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(7) bst.insert...
Python实现二叉搜索树
09-21
在Python中实现二叉搜索树，通常会定义两个类：`BinarySearchTree`和`TreeNode`。`BinarySearchTree`是整个树的容器，它有一个`TreeNode`类型的根节点，并且包含了一些基本操作，如`__init__`构造函数用于初始化空树...
BinarySearchTree:基于节点的二叉搜索树
06-10
在这个名为"BinarySearchTree:基于节点的二叉搜索树"的主题中，我们将深入探讨这种数据结构的关键特性、操作以及在Java中实现的细节。 二叉搜索树的主要特征是其排序性质：对于任意节点，其左子树中的所有节点的键...
BinarySearchTree:二叉搜索树算法演示
07-01
接下来，我们可以创建一个`BinarySearchTree`类来实现二叉搜索树的主要操作： ```java public class BinarySearchTree { private Node root; public BinarySearchTree() { this.root = null; } // 插入操作 ...
Search in a Binary Search Tree.zip
06-18
http://blog.csdn.net/xkzju2010/article/details/46399155
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1707
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
二叉搜索树(BinarySearchTree)
qq_52568001的博客
12-28 919
本文对二叉搜索树的一些基本概念还有操作进行了讲解 并进行了实现
二叉搜索树——BinarySearchTree
终为nullptr
02-08 1461
本文主要介绍了二叉搜索树的概念，特性，和实现，以及在介绍了面试中常考的一些题型
BinarySearchTree（二分查找树）
热门推荐
人生嘛！无非是左脚比右脚前，右脚再比左脚前，明天比今天好！
05-25 9万+
【代码】BinarySearchTree（二分查找树）
二叉搜索树 BinarySearchTree
阿振的博客
01-26 275
参考算法导论第三版第十二章： 二叉搜索树。实现代码：百度网盘， 提取密码：duri。  对二叉树进行这样的限制条件：对任意结点x，其左子树中所有关键字均小于x.key，其右子树中所有关键字均大于（等于）x.key。这样的二叉树被称为二叉搜索树。如下图：  可以看出，相同的关键字集合，能够构建出不同结构的二叉搜索树，而任意结构都满足二叉搜索树的性质。由于二叉搜索树关键字组织特性，树的
【C++与数据结构】搜索二叉树（BinarySearchTree）
最新发布
2303_80828380的博客
09-26 819
二叉树的模拟实现
二叉搜索树详解及C++实现
这个模板类`BinarySearchTree`代表二叉搜索树本身。它包含一个私有成员`m_root`，表示树的根节点。类提供了各种成员函数来操作二叉搜索树： - 构造函数：默认构造函数、拷贝构造函数。 - 析构函数：负责释放树...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值