投稿
  1. 首页
  2. 教程

【数据结构】二叉搜索树

游客 • 2月前 • 教程 • 阅读 417

【数据结构】二叉搜索树,第1张

【数据结构】二叉搜索树,第2张

樊梓慕：个人主页

 个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

每一个不曾起舞的日子，都是对生命的辜负

前言

本篇文章博主会对二叉搜索树的一些特性进行讲解，并且进行模拟实现。

欢迎大家收藏以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。

=========================================================================

GITEE相关代码：樊飞 (fanfei_c) - Gitee.com

=========================================================================

1.概念

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

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

2.模拟实现

2.1节点类

一般像这种链式结构，我们都要实现一个节点类出来用来构建联系。

  • 结点类当中包含三个成员变量：结点值、左指针、右指针。
template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;	BSTreeNode(const K& key = 0)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

2.2构造函数

因为这里的构造不需要特定的要求，只需要构造一棵空树，即给root赋值为nullptr即可。

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

或者你可以让系统自己生成一个默认的构造。

BSTree() = default;

2.3拷贝构造函数

注意这里完成的是深拷贝，不能是值拷贝，防止二次析构发生。

//拷贝构造函数
BSTree(const BSTree<K>& t)
{
    _root = Copy(t._root);
}//设置private限定，不要暴露该接口
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;
}

2.4赋值运算符重载

在之前数据结构的模拟实现中，一般对于赋值运算符这块我们已经学习了现代写法，直接swap即可。

//赋值运算符重载函数
BSTree<K>& operator=(BSTree<K> t)
{
	swap(_root, t._root);
	return *this;
}

原理：=的右值由于参数传递的不是引用，所以会调用自身的拷贝构造形成一个临时对象，交换临时对象与左值根节点后，此时左值根节点已经是之前的右值根节点了，然后返回左值根节点完成赋值，结束后右值根节点会被析构（即之前的左值）。

当然还有以下这种传统写法。

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

2.5析构函数

二叉树的析构一定采用『 后序』的方式。

//析构函数
~BSTree()
{
	Destroy(_root);
}void Destroy(Node* root)
{
	if (root == nullptr)
		return;	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

2.6查找函数

根据二叉搜索树的特性（左子树都小于根，右子树都大于根），我们在二叉搜索树当中查找指定值的结点的方式如下：

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

非递归方式： 

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

 递归方式：

bool FindR(const K& key)
{
    return _FindR(_root, key);
}//设置为private，不要暴露该接口
bool _FindR(Node* root, const K& key)
{
	if (root == nullptr)
		return false;	if (root->_key < key)
	{
		return _FindR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _FindR(root->_left, key);
	}
	else
	{
		return true;
	}
}

思考：为什么要设计成子函数这种形式呢？

因为当外部调用FindR时，我们没法直接传递根节点『 根节点是private域』，所以我们需要通过FindR获取到*this从而获取到_root，然后再调用_FindR，_FindR设计的参数为root和key就可以实现逻辑了，包括后面的递归方式都是这个思路。

2.7插入函数

插入的具体过程如下：

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

非递归方式： 

使用非递归方式实现二叉搜索树的插入函数时，找到插入位置后我们需要new新节点，然后将该节点与对应的父节点进行连接，所以我们需要定义一个parent指针，该指针用于标记待插入结点的父结点。

注意：连接parent和cur时，需要判断应该将cur连接到parent的左边还是右边。

//插入函数
bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}	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
		{
			return false;
		}
	}
	cur = new Node(key);	if (parent->_key < key) //key值大于当前parent结点的值
	{
		parent->_right = cur; //将结点连接到parent的右边
	}
	else //key值小于当前parent结点的值
	{
		parent->_left = cur; //将结点连接到parent的左边
	}
	return true;
}

递归方式：

同样的，对于递归方式来讲，我们如何将新节点与父节点进行连接呢？

这里只需要给参数上加一个『 引用』即可。

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

2.8删除函数

二叉搜索树的删除函数情况比较复杂，场景比较多。

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

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

分情况进行讨论：

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

若待删除结点的左子树为空，那么找到待删除结点后，只需先让其父结点指向该结点的右孩子结点，然后再将该结点释放。

（2）待删除结点的右子树为空。

若待删除结点的右子树为空，那么找到待删除结点后，只需先让其父结点指向该结点的左孩子结点，然后再将该结点释放。

（3）待删除结点的左右子树均不为空。

比如以下场景，要删除节点『 7』。

【数据结构】二叉搜索树,第3张

利用替换法：

step1：

  • 将待删除结点与待删除结点左子树当中值最大的结点“替换”（这里的替换指将该最大节点赋值给待删除节点）
  • 或者将待删除结点与待删除结点右子树当中值最小的结点“替换”（这里的替换指将该最小节点赋值给待删除节点）『 以此为例』

【数据结构】二叉搜索树,第4张

step2：

然后将该替换后的节点删除，该替换后的节点必然左右子树当中至少有一个为空树，因此删除该结点的方法与前面说到的情况一和情况二的方法相同。

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

【数据结构】二叉搜索树,第5张

非递归方式：

  • 使用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
}

 递归方式：

在找到了待删除节点后的思路与 *** 作一样，未找到之前改换为递归方式即可。 

bool _EraseR(Node*& root, const K& key)
{
	if (root == nullptr) 
		return 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的结点
}

3.二叉搜索树的应用

3.1『 K模型』

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

比如：

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

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

3.2『 KV模型』

每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：

  • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
  • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;		Node* _left;
		Node* _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:
		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}			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
				{
					return false;
				}
			}			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->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				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->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}						delete cur;
						return true;
					}
					else
					{
						// 替换法
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}						cur->_key = rightMin->_key;						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;						delete rightMin;
						return true;
					}
				}
			}			return false;
		}		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}	private:
		Node* _root = nullptr;
	};
}

4.二叉树的性能分析

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

对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

【数据结构】二叉搜索树,第6张

  • 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log(N)
  • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N/2

时间复杂度描述的是最坏情况下算法的效率，因此普通二叉搜索树各个 *** 作的时间复杂度都是O(N)。

如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？（即log(N)）

我们后面会学习AVL树与红黑树，他们对二叉搜索树进行了一定的优化，使得二叉搜索树的性能都能达到最优。

=========================================================================

如果你对该系列文章有兴趣的话，欢迎持续关注博主动态，博主会持续输出优质内容

博主很需要大家的支持，你的支持是我创作的不竭动力

~ 点赞收藏＋关注 ~

=========================================================================

欢迎分享，转载请注明来源：内存溢出

原文地址: https://outofmemory.cn/tougao/13518590.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
游客 游客 游客组
0 0
上一篇 2024-02-07
下一篇 2024-02-12

发表评论

登录后才能评论

评论列表（0条）

保存