二叉搜索树

太早162

已于 2023-07-09 09:43:17 修改

阅读量69

点赞数

文章标签：算法数据结构

于 2023-07-09 09:27:06 首次发布

本文链接：https://blog.csdn.net/weixin_66831846/article/details/131562295

版权

树的介绍

树是一种非线性数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，把它叫做“树”是因为它看起来像一棵倒挂的树，叶子朝下，根朝上。
树具有以下特点：
1、每个结点有零个或多个子结点；
2、没有父结点的结点称为根结点；
3、每一个非根结点，有且只有一个父结点；
4、除了根结点外，每个子结点，可以分为多个不相交子树；

树的基本术语

若一个结点有子树，该结点称为子树根的“双亲”，子树的根是该结点的“孩子”。有相同“双亲”的结点互为“兄弟”。
结点的度：结点拥有子树的数目。如上图的A、C结点的度为二，D、E、F的度为零。
叶子：度为零的节点。如上图的，D、E、F结点为树的叶子。
层次：根结点的层次为1。
树的高度：树中节点的最大层次。如上图的树高为3。

二叉树介绍

定义：每个结点最多有两个子树的树结构。
二叉树性质：
性质1：二叉树第i层上的结点数目最多为2^(i-1)个结点。
性质2：深度为K的二叉树最多有这2^k-1个结点。
性质3：包含n个结点的树高K=log2(n+1)。
性质4：二叉树中，设叶子节点数为n，度为2的结点数为n2，则no=n2+1，也就是说在二叉树中度为0的结点比度为2的节点多1个。

不同形态的二叉树

满二叉树
定义：高度为K，并由2^k-1个结点的组成的二叉树，称为满二叉树。

完全二叉树
一定义：一棵二叉树中，只有最下面两层结点的度可以小子2，并且最下面一层的叶子结点集中在靠左的位置上。这样的二叉树称为完全二叉树。
特点：叶子节点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左边位置。不能有间隔，一棵满二叉树必定是一棵完全二树。

二叉搜索树

特点：设x为二叉搜索树中的一个结点，X结点包含关键字ken，比ken小的值排在x的左边，比key大的值排在X的右边。当用中遍历二对搜索树时可以车出有序的数。
二叉搜索树满足以下性质
1、非空左子树的所有结点值小于根节点的值。
2、非空右子树的的所有值大于其根结点的值。
3、左右子树都是二叉树。

二叉搜索树的实现

我们先来实现一个简单的二叉搜索树，在二叉搜索树结点中，成员变量有：结点值、左指针、右指针，要实现一个可以用于存放多种类型的值的二对搜索树，可以先实现一个结点模版。在结点模板类中只需要实现的构造函数。

/结点模板
template<class K>
struct BSTreeNode
{
	K _key;                //结点值
	BSTreeNode<K>* _left;//左指针
	BSTreeNode<K>* _right;//右指针
//构造函数
	BSTreeNode(const K&key):_key(key),_left(nullptr),_right(nullptr)
	{}
};

树的构造函数

构造一棵空树。

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

树的拷贝构造函数

在堆区重新申请一个结点的空间（深拷贝）用于存放需要拷贝的结点值。

// 定义二叉搜索树的拷贝构造函数
	Node * copyTree(Node* root)
	{
		if (root == nullptr) 
		{
			return nullptr;
		}

		Node* newNode = new Node(root->_key);//拷贝结点值
		newNode->_left = copyTree(root->_left);//拷贝左子树
		newNode->_right = copyTree(root->_right);//拷贝右子树
		return newNode;
	}
	//拷贝构造函数
	BSTree(const BSTree<K>& t)
	{
		_root = copyTree(t._root);
	}

树的赋值运算符重载函数

传统写法

const BSTree<k>&operator=(const BSTree<K>&t)
{
    if(this!=&t)//防止自己给自己赋值
{
_root=copyTree(t._root);//拷贝树
}
rturn *this;

}

现代写法

BSTree<K>&operator=(BSTree<K>t)
{
    swap(_rooe,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;
	}

结点的插入函数

也就是在已有的树中新增一个结点。插入的具体过程如下：

a. 树为空，则直接新增节点，赋值给_root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

树不为空，插入步骤如下：

1、若待插入值小于根结点的值，则将该值插入根结点的左子树中。
2、若待插入值大于根结点的值，则将该值插入根结点的右子树中。
3、若待插入值等于根结点的值，则插入失败。

插入演示：

非递归插入结点代码如下：


	//非递归插入结点
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);//空树直接申请一个结点
		}
		Node* parent = nullptr;//记录待插入结点的父结点
		Node* cur = _root;
		while (cur)
		{
			if (key < _root->_key)//key小于当前节点的只
			{
				//去该节点的左子树找
				parent = cur;
				cur = cur->_left;
			}
			else if(key>_root->_key )
			{
				//去该节点的右子树找
				parent = cur;
				cur = cur->_right;

			}
			else
			{
				return false;//插入值以存在
			}
		}
		cur= new Node(key);//申请一个节点
		if (key < parent->_key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}

递归插入结点代码如下：

	//递归插入
	bool _Insert(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (key < root->_key)
		{
			return _Insert(root->_left, key);
		}
		else if (key > root->_key)
		{
			return _Insert(root->_right, key);
		}
		else
		{
			return false;
		}
	}
	bool Insert(const K& key)
	{
		return _Insert(_root, key);
	}

删除树的结点

二叉搜索树删除结点，可以说是二叉搜索树中最为复杂的操作，因为要考虑的情况比较多。

对树的结点的删除可以分为以下三种情况：

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

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

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

我们先来分析待删除结点的左子树为空的情况。

当待删除除结点的左子树为空时，这时我们可以让待删除结点的父结点，指向待删除结点的右子树，再将待删除结点释放。例如下图，当我们要删除以下二叉树中16这个结点，16结点的左子树为空，我们只需将16结点的父结点，原本指向16结点的指针指向16结点的右子树17，再将16这个结点释放，即可。

当待删除的结点的右子树为空。

当待删除除结点的右子树为空时，这时我们可以让待删除结点的父结点，指向待删除结点的左子树，再将待删除结点释放。例如下图，当我们要删除以下二叉树中20这个结点，20结点的右子树为空，我们只需将20结点的父结点，原本指向20结点的指针改为指向20结点的右子树19，再将20这个结点释放，即可。

当待删除结点的左右子树均不为空时

我们可以使用替待法进行删除，所谓的替代法就是在左子树中寻找左子树最大值进行替代或在右子树中找到最小值替代特删除结点，我们以右子树中最小值替代为例。

过程演示：

非递归实现

方法一

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

//删除节点1

	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//如果待删除节点的key值等于当前节点的值，则找到了要删除的节点
			{
				if (cur->_left == nullptr)//待删除节点的左子树为空
				{
					if (cur == _root)//待删除节点为根节点
					{
						_root= cur->_right;
					}
					else//待删除不为节点为根节点
					{
						if (cur == parent->_left)//待删除为父节点的左孩子
						{
							parent->_left = cur->_right;//将父节点的左指针指向待删除节点的右孩子
						}
						else//待删除节点是父节点的右孩子
						{
							//因为待删除节点的左子树为空直接让父节点的右指针指向待删除节点的右子树
							parent->_right = cur->_left;
						}
					}
					delete cur;
					return true;

				}
				else if (cur->_right == nullptr)//待删除节点的右子树为空
				{
					if (cur == _root) //待删除节点为根节点
					{
						_root = cur->_left;//更新树的节点
					}
					else//待删除节点不为根节点
					{
						if (cur == parent->_left)//待删除为父节点的左孩子
						{
							parent->_left = cur->_left;//将父节点的左指针指向待删除节点的左孩子
						}
						else
						{
							parent->_right = cur->_left;//将父节点的右指针指向待删除节点的左孩子
						}

					}
					delete cur;
					return true;
				}
				else//待删除节点的左右子树均不为空
				{
					Node* minParent = cur;//用于记录待删除节点右子树中最小节点的父节点
					Node* minRight = cur->_right;//用于记录待删除节点右子树中最小节点


					//查找待删除节点右子树中最小节点
					while (minRight->_left)
					{
						// 待删除节点右子树中最小节点位于右子树中最左的位置所以一种往右子树走
						minParent = minRight;
						minRight =minRight->_left;
					}
					//更改待待删除节点的位置
					cur->_key = minRight->_key;

					if (minRight == minParent->_left)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
					return true;

				}
			}
		}
		return false;
	}

方法二
在遇到待删除结点左右子树不为空的情况时，找到右子树中值最小的结点，用minRight记录，再去调用删除函数删除minRight——>_key，将待删除结点的右子树的最小值删除后，再将待删练的节点的值改为minRight——>_key。

//删除函数（方法二）
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

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

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

//递归删除函数的子函数1
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
	}
}
//递归删除函数1
bool EraseR(const K& key)
{
	return _EraseR(_root, key); //删除_root当中值为key的结点
}

递归实现删除2

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

//递归删除函数的子函数2
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
	}
}
//递归删除函数2
bool EraseR(const K& key)
{
	return _EraseR(_root, key); //删除_root当中值为key的结点
}

查找结点

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

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

非递归查找

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

若树为空树，则查找失败，返回nullptr。
若key值小于当前结点的值，则应该在该结点的左子树当中进行查找。
若key值大于当前结点的值，则应该在该结点的右子树当中进行查找。
若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==cur->_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的结点
}

太早162

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉搜索树

树是一种非线性数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，把它叫做“树”是因为它看起来像一棵倒挂的树，叶子朝下，根朝上。树具有以下特点：1、每个结点有零个或多个子结点；2、没有父结点的结点称为根结点；3、每一个非根结点，有且只有一个父结点；4、除了根结点外，每个子结点，可以分为多个不相交子树；定义：每个结点最多有两个子树的树结构。二叉树性质：性质1：二叉树第i层上的结点数目最多为2^(i-1)个结点。
复制链接

扫一扫