二叉搜索树

已于 2023-10-17 13:40:19 修改
阅读量1.5w 收藏 99
点赞数 56
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
于 2021-11-04 21:48:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenlong_cxy/article/details/121089149
版权

文章目录

二叉搜索树的概念

二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

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

例如，下面就是一棵二叉搜索树：
在这里插入图片描述
由于二叉搜索树中，每个结点左子树上所有结点的值都小于该结点的值，右子树上所有结点的值都大于该结点的值，因此对二叉搜索树进行中序遍历后，得到的是升序序列也就不难理解了。

二叉搜索树的实现

结点类

要实现二叉搜索树，我们首先需要实现一个结点类：

  • 结点类当中包含三个成员变量：结点值、左指针、右指针。
  • 结点类当中只需实现一个构造函数即可，用于构造指定结点值的结点。
//结点类
template<class K>
struct BSTreeNode
{
	K _key;                 //结点值
	BSTreeNode<K>* _left;   //左指针 
	BSTreeNode<K>* _right;  //右指针

	//构造函数
	BSTreeNode(const K& key = 0)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

各函数接口总览+小技巧

二叉搜索树需要实现的函数接口如下：

//二叉搜索树
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//构造函数
	BSTree();

	//拷贝构造函数
	BSTree(const BSTree<K>& t);

	//赋值运算符重载函数
	BSTree<K>& operator=(BSTree<K> t);

	//析构函数
	~BSTree();

	//插入函数
	bool Insert(const K& key);

	//删除函数
	bool Erase(const K& key);

	//查找函数
	Node* Find(const K& key);

	//中序遍历
	void InOrder();
private:
	Node* _root; //指向二叉搜索树的根结点
};

小技巧

为了在实现其他接口的过程中方便随时检查，最好实现一个二叉搜索树的中序遍历接口，当我们对二叉搜索树进行一次操作后，可以调用中序遍历接口对二叉搜索树进行遍历，若二叉搜索树进行操作后的遍历结果仍为升序，则可以初步判断所实现的接口是正确。

//中序遍历的子函数
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;
	_InOrder(root->_left); //遍历左子树
	cout << root->_key << " "; //遍历根结点
	_InOrder(root->_right); //遍历右子树
}
//中序遍历
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

构造函数

构造函数非常简单，构造一个空树即可。

//构造函数
BSTree()
	:_root(nullptr)
{}

拷贝构造函数

拷贝构造函数也并不难，拷贝一棵和所给二叉搜索树相同的树即可。

//拷贝树
Node* _Copy(Node* root)
{
	if (root == nullptr) //空树直接返回
		return nullptr;

	Node* copyNode = new Node(root->_key); //拷贝根结点
	copyNode->_left = _Copy(root->_left); //拷贝左子树
	copyNode->_right = _Copy(root->_right); //拷贝右子树
	return copyNode; //返回拷贝的树
}
//拷贝构造函数
BSTree(const BSTree<K>& t)
{
	_root = _Copy(t._root); //拷贝t对象的二叉搜索树
}

注意： 拷贝构造函数完成的是深拷贝。

赋值运算符重载函数

对于赋值运算符重载函数，下面提供两种实现方法：

传统写法

先将当前二叉搜索树中的结点释放，然后完成所给二叉搜索树的拷贝即可。

//传统写法
const BSTree<K>& operator=(const BSTree<K>& t)
{
	if (this != &t) //防止自己给自己赋值
	{
		_Destory(_root); //先将当前的二叉搜索树中的结点释放
		_root = _Copy(t._root); //拷贝t对象的二叉搜索树
	}
	return *this; //支持连续赋值
}

现代写法

赋值运算符重载函数的现代写法非常精辟，函数在接收右值时并没有使用引用进行接收，因为这样可以间接调用BSTree的拷贝构造函数完成拷贝构造。我们只需将这个拷贝构造出来的对象的二叉搜索树与this对象的二叉搜索树进行交换，就相当于完成了赋值操作，而拷贝构造出来的对象t会在该赋值运算符重载函数调用结束时自动析构。

//现代写法
BSTree<K>& operator=(BSTree<K> t) //编译器接收右值的时候自动调用拷贝构造函数
{
	swap(_root, t._root); //交换这两个对象的二叉搜索树
	return *this; //支持连续赋值
}

注意： 这里传统写法和现代写法完成的都是深拷贝。

析构函数

析构函数完成对象中二叉搜索树结点的释放，注意释放时采用后序释放，当二叉搜索树中的结点被释放完后，将对象当中指向二叉搜索树的指针及时置空即可。

//释放树中结点
void _Destory(Node* root)
{
	if (root == nullptr) //空树无需释放
		return;

	_Destory(root->_left); //释放左子树中的结点
	_Destory(root->_right); //释放右子树中的结点
	delete root; //释放根结点
}
//析构函数
~BSTree()
{
	_Destory(_root); //释放二叉搜索树中的结点
	_root = nullptr; //及时置空
}

插入函数

根据二叉搜索树的性质，其插入操作非常简单：

  1. 如果是空树，则直接将插入结点作为二叉搜索树的根结点。
  2. 如果不是空树，则按照二叉搜索树的性质进行结点的插入。

若不是空树，插入结点的具体操作如下：

  1. 若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中。
  2. 若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中。
  3. 若待插入结点的值等于根结点的值，则插入结点失败。

如此进行下去，直到找到与待插入结点的值相同的结点判定为插入失败，或者最终插入到某叶子结点的左右子树当中（即空树当中）。

动图演示：
在这里插入图片描述

非递归实现

使用非递归方式实现二叉搜索树的插入函数时，我们需要定义一个parent指针，该指针用于标记待插入结点的父结点。
这样一来，当我们找到待插入结点的插入位置时，才能很好的将待插入结点与其父结点连接起来。
在这里插入图片描述
但是需要注意在连接parent和cur时，需要判断应该将cur连接到parent的左边还是右边。

//插入函数
bool Insert(const K& key)
{
	if (_root == nullptr) //空树
	{
		_root = new Node(key); //直接申请值为key的结点作为二叉搜索树的根结点
		return true; //插入成功，返回true
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key) //key值小于当前结点的值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) //key值大于当前结点的值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //key值等于当前结点的值
		{
			return false; //插入失败，返回false
		}
	}
	cur = new Node(key); //申请值为key的结点
	if (key < parent->_key) //key值小于当前parent结点的值
	{
		parent->_left = cur; //将结点连接到parent的左边
	}
	else //key值大于当前parent结点的值
	{
		parent->_right = cur; //将结点连接到parent的右边
	}
	return true; //插入成功，返回true
}

递归实现

递归实现二叉搜索树的插入操作也是很简单的，但是要特别注意的一点就是，递归插入函数的子函数接收参数root时，必须采用引用接收，因为只有这样我们才能将二叉树当中的各个结点连接起来。

//递归插入函数的子函数
bool _InsertR(Node*& root, const K& key) //注意引用
{
	if (root == nullptr) //空树
	{
		root = new Node(key); //直接申请值为key的结点作为树的根结点
		return true; //插入成功，返回true
	}

	if (key < root->_key) //key值小于根结点的值
	{
		return _InsertR(root->_left, key); //应将结点插入到左子树当中
	}
	else if (key > root->_key) //key值大于根结点的值
	{
		return _InsertR(root->_right, key); //应将结点插入到右子树当中
	}
	else //key值等于根结点的值
	{
		return false; //插入失败，返回false
	}
}
//递归插入函数
bool InsertR(const K& key)
{
	return _InsertR(_root, key); //调用子函数进行插入
}

删除函数

二叉搜索树的删除函数是最难实现的，若是在二叉树当中没有找到待删除结点，则直接返回false表示删除失败即可，但若是找到了待删除结点，此时就有以下三种情况：

  1. 待删除结点的左子树为空（待删除结点的左右子树均为空包含在内）。
  2. 待删除结点的右子树为空。
  3. 待删除结点的左右子树均不为空。

下面我们分别对这三种情况进行分析处理：

1、待删除结点的左子树为空

若待删除结点的左子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的右孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

动图演示：
在这里插入图片描述

2、待删除结点的右子树为空

若待删除结点的右子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的左孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

动图演示：
在这里插入图片描述

3、待删除结点的左右子树均不为空

若待删除结点的左右子树均不为空，那么当我们在二叉搜索树当中找到该结点后，可以使用替换法进行删除。
可以将让待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除（下面都以后者为例），然后将待删除结点的值改为代替其被删除的结点的值即可。而代替待删除结点被删除的结点，必然左右子树当中至少有一个为空树，因此删除该结点的方法与前面说到的情况一和情况二的方法相同。

注意只能是待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除，因为只有这样才能使得进行删除操作后的二叉树仍保持二叉搜索树的特性。

动图演示：
在这里插入图片描述

非递归实现

对于二叉搜索树删除函数的实现，在删除左右子树均不为空的结点时有两种不同的思路，因此实现删除函数的方法有以下两种。

方法一：

方法一在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：

  • 使用minParent标记待删除结点右子树当中值最小结点的父结点。
  • 使用minRight标记待删除结点右子树当中值最小的结点。

当找到待删除结点右子树当中值最小的结点时，先将待删除结点的值改为minRight的值，之后直接判断此时minRight是minParent的左孩子还是右孩子，然后对应让minParent的左指针或是右指针转而指向minRight的右孩子（注意：minRight的左孩子为空），最后将minRight结点进行释放即可。

//删除函数（方法一）
bool Erase(const K& key)
{
	Node* parent = nullptr; //标记待删除结点的父结点
	Node* cur = _root; //标记待删除结点
	while (cur)
	{
		if (key < cur->_key) //key值小于当前结点的值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) //key值大于当前结点的值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //找到了待删除结点
		{
			if (cur->_left == nullptr) //待删除结点的左子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_right; //二叉搜索树的根结点改为根结点的右孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_right; //父结点的左指针指向待删除结点的右子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_right; //父结点的右指针指向待删除结点的右子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else if (cur->_right == nullptr) //待删除结点的右子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_left; //二叉搜索树的根结点改为根结点的左孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_left; //父结点的左指针指向待删除结点的左子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_left; //父结点的右指针指向待删除结点的左子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else //待删除结点的左右子树均不为空
			{
				//替换法删除
				Node* minParent = cur; //标记待删除结点右子树当中值最小结点的父结点
				Node* minRight = cur->_right; //标记待删除结点右子树当中值最小的结点
				//寻找待删除结点右子树当中值最小的结点
				while (minRight->_left)
				{
					//一直往左走
					minParent = minRight;
					minRight = minRight->_left;
				}
				cur->_key = minRight->_key; //将待删除结点的值改为minRight的值
				//注意一个隐含条件：此时minRight的_left为空
				if (minRight == minParent->_left) //minRight是其父结点的左孩子
				{
					minParent->_left = minRight->_right; //父结点的左指针指向minRight的右子树即可
				}
				else //minRight是其父结点的右孩子
				{
					minParent->_right = minRight->_right; //父结点的右指针指向minRight的右子树即可
				}
				delete minRight; //释放minRight
				return true; //删除成功，返回true
			}
		}
	}
	return false; //没有找到待删除结点，删除失败，返回false
}

方法二：

方法二在遇到待删除结点的左右子树均不为空的情况时的处理方式与方法一不同，方法二在找到待删除结点右子树当中值最小的结点后，先将minRight的值记录下来，然后再重新调用删除函数删除二叉树当中的minRight，当minRight被删除后再将原待删除结点的值改为minRight的值，这样也完成了左右子树均不为空的结点的删除。

//删除函数（方法二）
bool Erase(const K& key)
{
	Node* parent = nullptr; //标记待删除结点的父结点
	Node* cur = _root; //标记待删除结点
	while (cur)
	{
		if (key < cur->_key) //key值小于当前结点的值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) //key值大于当前结点的值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //找到了待删除结点
		{
			if (cur->_left == nullptr) //待删除结点的左子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_right; //二叉搜索树的根结点改为根结点的右孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_right; //父结点的左指针指向待删除结点的右子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_right; //父结点的右指针指向待删除结点的右子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else if (cur->_right == nullptr) //待删除结点的右子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_left; //二叉搜索树的根结点改为根结点的左孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_left; //父结点的左指针指向待删除结点的左子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_left; //父结点的右指针指向待删除结点的左子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else //待删除结点的左右子树均不为空
			{
				//替换法删除
				Node* minRight = cur->_right; //标记待删除结点右子树当中值最小的结点
				//寻找待删除结点右子树当中值最小的结点
				while (minRight->_left)
				{
					//一直往左走
					minRight = minRight->_left;
				}
				K minKey = minRight->_key; //记录minRight结点的值
				Erase(minKey); //minRight代替待删除结点被删除
				cur->_key = minKey; //将待删除结点的值改为代替其被删除的结点的值，即minRight
			}
		}
	}
	return false; //没有找到待删除结点，删除失败，返回false
}

注意：

  1. 方法二的非递归删除函数，必须在调用删除函数删除minRight结点后，再将原待删除结点的值改为minRight的值，若逻辑顺序颠倒，则会导致在调用删除函数删除minRight结点时在二叉树当中存在两个满足要求的待删除结点。
  2. 非递归删除函数方法二和方法一在实现上只有一点不同，那就是处理待删除结点左右子树均不为空时的处理思路。
  3. 对于非递归删除函数的方法一和方法二来说，建议使用方法一，因为非递归删除函数方法二在删除左右子树均不为空的结点时，当找到minRight后还需要从二叉搜索树的根结点开始，重新遍历二叉树删除minRight结点。

递归实现

递归实现二叉搜索树的删除函数的思路如下：

  1. 若树为空树，则结点删除失败，返回false。
  2. 若所给key值小于树根结点的值，则问题变为删除左子树当中值为key的结点。
  3. 若所给key值大于树根结点的值，则问题变为删除右子树当中值为key的结点。
  4. 若所给key值等于树根结点的值，则根据根结点左右子树的存在情况不同，进行不同的处理。

而因为当待删除结点的左右子树均不为空时，处理方法有两种，所以删除函数的递归实现也有两种方法。

方法一：

方法一在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：

  • 使用minParent标记根结点右子树当中值最小结点的父结点。
  • 使用minRight标记根结点右子树当中值最小的结点。

当找到根结点右子树当中值最小的结点时，先根结点的值改为minRight的值，之后直接判断此时minRight是minParent的左孩子还是右孩子，然后对应让minParent的左指针或是右指针转而指向minRight的右孩子（注意：minRight的左孩子为空），最后将minRight结点进行释放即可。

//递归删除函数的子函数（方法一）
bool _EraseR(Node*& root, const K& key)
{
	if (root == nullptr) //空树
		return false; //删除失败，返回false

	if (key < root->_key) //key值小于根结点的值
		return _EraseR(root->_left, key); //待删除结点在根的左子树当中
	else if (key > root->_key) //key值大于根结点的值
		return _EraseR(root->_right, key); //待删除结点在根的右子树当中
	else //找到了待删除结点
	{
		if (root->_left == nullptr) //待删除结点的左子树为空
		{
			Node* del = root; //保存根结点
			root = root->_right; //根的右子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else if (root->_right == nullptr) //待删除结点的右子树为空
		{
			Node* del = root; //保存根结点
			root = root->_left; //根的左子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else //待删除结点的左右子树均不为空
		{
			Node* minParent = root; //标记根结点右子树当中值最小结点的父结点
			Node* minRight = root->_right; //标记根结点右子树当中值最小的结点
			//寻找根结点右子树当中值最小的结点
			while (minRight->_left)
			{
				//一直往左走
				minParent = minRight;
				minRight = minRight->_left;
			}
			root->_key = minRight->_key; //将根结点的值改为minRight的值
			//注意一个隐含条件：此时minRight的_left为空
			if (minRight == minParent->_left) //minRight是其父结点的左孩子
			{
				minParent->_left = minRight->_right; //父结点的左指针指向minRight的右子树即可
			}
			else //minRight是其父结点的右孩子
			{
				minParent->_right = minRight->_right; //父结点的右指针指向minRight的右子树即可
			}
			delete minRight; //释放minRight
		}
		return true; //删除成功，返回true
	}
}
//递归删除函数（方法一）
bool EraseR(const K& key)
{
	return _EraseR(_root, key); //删除_root当中值为key的结点
}

方法二：

方法二在遇到待删除结点的左右子树均不为空的情况时的处理方式与方法一不同，方法二在找到待删除结点右子树当中值最小的结点后，先将minRight的值记录下来，然后再重新调用递归删除函数的子函数从当前根结点的右子树开始，删除右子树当中的minRight，当minRight被删除后再将根结点的值改为minRight的值，这样也完成了左右子树均不为空的结点的删除。

//递归删除函数的子函数（方法二）
bool _EraseR(Node*& root, const K& key)
{
	if (root == nullptr) //空树
		return false; //删除失败，返回false

	if (key < root->_key) //key值小于根结点的值
		return _EraseR(root->_left, key); //待删除结点在根的左子树当中
	else if (key > root->_key) //key值大于根结点的值
		return _EraseR(root->_right, key); //待删除结点在根的右子树当中
	else //找到了待删除结点
	{
		if (root->_left == nullptr) //待删除结点的左子树为空
		{
			Node* del = root; //保存根结点
			root = root->_right; //根的右子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else if (root->_right == nullptr) //待删除结点的右子树为空
		{
			Node* del = root; //保存根结点
			root = root->_left; //根的左子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else //待删除结点的左右子树均不为空
		{
			Node* minRight = root->_right; //标记根结点右子树当中值最小的结点
			//寻找根结点右子树当中值最小的结点
			while (minRight->_left)
			{
				//一直往左走
				minRight = minRight->_left;
			}
			K minKey = minRight->_key; //记录minRight结点的值
			_EraseR(root->_right, minKey); //删除右子树当中值为minkey的结点，即删除minRight
			root->_key = minKey; //将根结点的值改为minRight的值
		}
		return true; //删除成功，返回true
	}
}
//递归删除函数（方法二）
bool EraseR(const K& key)
{
	return _EraseR(_root, key); //删除_root当中值为key的结点
}

注意：

  1. 实现递归删除函数时，不论是方法一还是方法二，递归删除函数子函数接收root参数时必须采用引用接收，否则无法完成二叉树当中各个结点的连接关系。
  2. 递归删除函数的方法二和方法一在实现上也只有一点不同，那就是处理待删除结点左右子树均不为空时的处理思路。
  3. 对于递归删除函数的方法一和方法二来说，建议使用方法二，因为方法二在删除左右子树均不为空的结点时，当找到minRight后就无需从二叉搜索树的根结点开始，重新遍历二叉树删除minRight结点了，并且递归删除函数方法二写法的可读性更高。

查找函数

根据二叉搜索树的特性，我们在二叉搜索树当中查找指定值的结点的方式如下：

  1. 若树为空树，则查找失败，返回nullptr。
  2. 若key值小于当前结点的值，则应该在该结点的左子树当中进行查找。
  3. 若key值大于当前结点的值，则应该在该结点的右子树当中进行查找。
  4. 若key值等于当前结点的值，则查找成功，返回对应结点的地址。

动图演示：
在这里插入图片描述

非递归实现

二叉搜索树查找函数的非递归实现如下：

//查找函数
Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key) //key值小于该结点的值
		{
			cur = cur->_left; //在该结点的左子树当中查找
		}
		else if (key > cur->_key) //key值大于该结点的值
		{
			cur = cur->_right; //在该结点的右子树当中查找
		}
		else //找到了值为key的结点
		{
			return cur; //查找成功，返回结点地址
		}
	}
	return nullptr; //树为空或查找失败，返回nullptr
}

递归实现

二叉搜索树查找函数的递归实现如下：

//递归查找函数的子函数
Node* _FindR(Node* root, const K& key)
{
	if (root == nullptr) //树为空
		return nullptr; //查找失败，返回nullptr

	if (key < root->_key) //key值小于根结点的值
	{
		return _FindR(root->_left, key); //在根结点的左子树当中查找
	}
	else if (key > root->_key) //key值大于根结点的值
	{
		return _FindR(root->_right, key); //在根结点的右子树当中查找
	}
	else //key值等于根结点的值
	{
		return root; //查找成功，返回根结点地址
	}
}
//递归查找函数
Node* FindR(const K& key)
{
	return _FindR(_root, key); //在_root当中查找值为key的结点
}

二叉搜索树的应用

K模型

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

比如：给定一个单词，判断该单词是否拼写正确。具体方式如下：

  1. 以单词集合中的每个单词作为key，构建一棵二叉搜索树。
  2. 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

KV模型

KV模型，对于每一个关键码key，都有与之对应的值value，即<key, value>的键值对。

比如：英汉词典就是英文与中文的对应关系，即<word, Chinese>就构成一种键值对。具体方式如下：

  1. 以<单词, 中文含义>为键值对，构建一棵二叉搜索树。注意：二叉搜索树需要进行比较，键值对比较时只比较key。
  2. 查询英文单词时，只需给出英文单词就可以快速找到与其对应的中文含义。

二叉搜索树的性能分析

对于二叉搜索树来说，无论的插入查找还是删除操作，都需要先进行查找，因此查找的效率代表了二叉搜索树中各个操作的性能。

对于二叉搜索树这棵特殊的二叉树，我们每进行一次查找，若未查找到目标结点，则还需查找的树的层数就减少了一层，所以我们最坏情况下需要查找的次数就是二叉搜索树的深度，深度越深的二叉搜索树，比较的次数就越多。

对于有n个结点的二叉搜索树：

  • 最优的情况下，二叉搜索树为完全二叉树，其平均比较次数为： l o g N logN logN
  • 最差的情况下，二叉搜索树退化为单支树，其平均比较次数为： N / 2 N/2 N/2

在这里插入图片描述
而时间复杂度描述的是最坏情况下算法的效率，因此普通二叉搜索树各个操作的时间复杂度都是 O ( N ) O(N) O(N)。

所以实际上，二叉搜索树在极端情况下是没办法保证效率的，因此由二叉搜索树又衍生出来了AVL树、红黑树等，它们对二叉搜索树的高度进行了优化，使得二叉搜索树非常接近完全二叉树，因此对于这些树来说，它们的效率是可以达到 O ( l o g N ) O(logN) O(logN)的。

顺便说一下： B树和B+树是查找存储在磁盘当中的数据时经常用到的数据结构，B树系列对树的高度提出了更高的要求，此时二叉树已经不能满足要求了，为了降低树的高度，于是衍生出了多叉树，而实际上这些树都是由二叉搜索树演变出来的，它们各有各的特点，适用于不同的场景。

2021dragon
关注
  • 56
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 26
    评论
专栏目录
【C++详解】——搜索二叉树
weixin_69519040的博客
04-22 568
本文介绍了搜索二叉树的原理，并且模拟实现了一个搜索二叉树，其中插入、删除、查找功能分别使用了递归和非递归两种实现方式。本文还介绍了两种搜索二叉树的应用场景，根据相应的应用场景将搜索二叉树改造成了KV结构。 本文详细代码链接：https://gitee.com/hrimkn
C++之搜索二叉树
一只小卷毛的博客
04-05 952
本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。
二叉查找树详解
最新发布
m0_72674633的博客
06-08 1043
二叉查找树详解
二叉树遍历查找
心猿意碼
05-08 344
1)前序遍历:先输出父节点，再遍历左子树和右子树 2)中序遍历:先遍历左子树，再输出父节点，再遍历右子树 3)后序遍历:先遍历左子树，再遍历右子树，最后输出父节点 4)小结:看输出父节点的顺序，就确定是前序，中序还是后序 package com.atguigu.tree; public class BinaryTreeDemo { public static void mai...
【C++】二叉搜索树（概念、实现、应用）
ZZZCCC的博客
04-24 427
在分块讲解前，我们要明白，递归要传根节点，但是用户平常使用这些借口并不会传根节点，而是直接调用，所以我们嵌套一层，这样就可以满足双方的需求了。可以在递归的参数中多一个父亲结点，每次递归都更新一下Parent，然后再带到下一层递归。由于没有二叉搜索树的官方库，我们增删查改的实现需要我们自己来完成，见下面的模拟实现。递归这种思想我么你还需要多加理解，下一章将详细讲解OJ题目，加深我们对于递归的理解！采用递归方式的缺点就是如果数的结点个数足够多的时候，就会有爆栈的风险！当出现单边树的情况时，就是〇（N）的情况。
二叉搜索树(二叉排序树)
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点： 1. 节点的左...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
二叉搜索树_二叉搜索树_源码
10-04
在给定的“二叉搜索树_二叉搜索树_源码”压缩包中，包含了一个名为“二叉搜索树.c”的源代码文件和一个编译后的可执行文件“二叉搜索树.exe”。源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
Java二叉搜索树基础原理与实现方法详解
08-19
Java二叉搜索树基础原理与实现方法详解 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、编程实现等方面的知识点。 一、树的定义 树是n（n>=0）个...
二叉搜索树的应用
iwkxi的博客
08-18 1236
首先，我们的目的是查找Key的时候随便查找Value，所以节点的结构、Insert和new的时候都要增加第二个参数Value。递归时，我们很容易知道当前节点的前一个节点是什么，但是无法知道下一个节点是什么，所以我们不能改变当前节点的右指针(后继指针)。再比如检查一篇文章单词释放拼写错误：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树，在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。考虑用栈来存储p、q的路径，让路径长的先走，路径相等后同时走，转换成求两个路径的交点。...
二叉搜索树与优先级队列及其堆的应用
m0_65190367的博客
10-17 812
1.第一次调用构造方法实例化出一个PriorityQueue对象时，相当于new一个长度为默认值的数组；2.如果调用构造方法时，传入一个数值，就会调用初始化数组的构造方法；如果调用构造方法时，传入一个比较器，就会调用实例化比较器的构造方法；3.插入元素：如果是第一次插入：直接放在0下标的位置；如果不是第一次插入，并且没有传入比较器，那么首先要保证传入的对象是可比较的，其次offer方法会自动new一个可比较的key对象，再根据向上调整，最后选择合适位置放入元素；
数据结构——二叉搜索树详解
热门推荐
L_T_W_Y的博客
09-04 4万+
二叉搜索树 一、什么是二叉搜索树 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树。 二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有键值小于其根结点的键值。 非空右子树的所有键值大于其根结点的键值。 左、右子树都是二叉搜索树。 下图是几个例子： 上图值为10的结点的右子树为7，比10小，不满足条件2，所以这棵树不是二叉搜索树。 上图各个结点都满足条件，所以这棵树是二叉搜索树。 上图各个结点都满足条件，所以这棵树也是二叉搜索树

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2021dragon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值