二叉搜索树的(查找、插入、删除)

已于 2023-08-22 14:43:32 修改
阅读量124 收藏 1
点赞数 2
分类专栏： c++ 文章标签： 算法
于 2023-08-22 14:38:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50601177/article/details/132421396
版权

一、二叉搜索树的概念

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

1、若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；

2、若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；

3、它的左右子树也分别为二叉搜索树

下图就是一个二叉搜索树：

二、二叉树的定义

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _right;
	BSTreeNode<K>* _left;
	K _key;

	BSTreeNode(const K& key = K())
		:_right(nullptr)
		,_left(nullptr)
		,_key(key)
	{
	}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
    bool find(const K& key){}//查找
    bool insert(const K& key){}//插入 
	bool erase(const K& key){}//删除
private：
    Node* _root;
};

三、二叉搜索树的查找节点

非递归写法：

如果root为空，那么查找失败，没有要查找的节点；如果root不为空，比较root->key和要查找的值，如果要查找的值大于root->key，就到右子树接着找，反之，到左子树接着找。找到返回true，没有找到返回false。

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

递归写法：

查找思想还是和非递归一样的，如果root为空，返回false，如果root->key大于要找的值，那么递归到左子树去找（转换成一个子问题），反之，递归到右子树去找。

    
    bool findR(const K& key)
	{
		return _findR(_root, key);
	}


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

四、二叉搜索树的插入节点

非递归写法：

要插入一个数据，首先得找到插入的位置，所以插入分为两大步：

1、找到要插入的位置

如果树中存在一个节点的key与要插入的数相同，则不会插入。找位置的时候要同时有一个指针记录父节点，走到空就结束

2、插入数据

判断插入的数据比父节点大还是小，如果小则插在左边，反之则插在右边

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

递归写法：

    bool insertR(const K& key)
	{
		return _insertR(_root, key);
	}

    //这里要传引用，我们就不需要找父节点了
    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;
		}
	}

五、二叉搜索树的删除节点

删除节点大致可分为三种情况：

1、要删除节点左右都为空；

2、要删除节点左为空或右为空；

3、要删除节点左右都不为空。

第一点和第二点又可以看成一点。

要注意特殊情况：要删除的节点是根节点。

非递归写法：

    bool erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			//找到要被删的节点了
			else
			{
				//1、要删除的这个节点是叶子节点或度为1（可直接删除）
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}
				}
				else if(cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right = cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
				}
				//2、要删除的这个节点度为2（替换法）
				else
				{
					//找左树中的最大值或右树中的最小值与被删节点交换，再删除
					//找左树中的最大值
					Node* leftMax = cur->_left;
					Node* PLeftMax = cur;
					while (leftMax->_right)
					{
						PLeftMax = leftMax;
						leftMax = leftMax->_right;
					}
					
					swap(cur->_key, leftMax->_key);//交换值
					//删除leftMax
					if (PLeftMax->_right == leftMax)
					{
						if (leftMax->_right == nullptr)
						{
							PLeftMax->_right = leftMax->_left;
						}
						else
						{
							PLeftMax->_right = leftMax->_right;
						}
					}
					if (PLeftMax->_left == leftMax)
					{
						if (leftMax->_right == nullptr)
						{
							PLeftMax->_left = leftMax->_left;
						}
						else
						{
							PLeftMax->_left = leftMax->_right;
						}
					}
					cur = leftMax;
				}
				delete cur;
				return true;
			}
		}
		return false;
	}

递归写法：

    bool eraseR(const K& key)
	{
		return _eraseR(_root, key);
	}

    bool _eraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _eraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _eraseR(root->_left, key);
		}
		else
		{
			Node* del = root;
			//找到了被删除节点
			//1、左为空或右为空或左右都为空
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			//2、左右都不为空
			else
			{
				//左树找最大值
				Node* LeftMax = root->_left;
				while (LeftMax->_right)
				{
					LeftMax = LeftMax->_right;
				}
				swap(root->_key, LeftMax->_key);
				

				//删除LeftMax节点
				return _eraseR(root->_left, key);
			}
			delete del;
			return true;
		}
	}

六、二叉搜索树的应用

1、K模型（也就是我们后面学是set）：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

2、KV模型（也就是我们后面学是map）：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。

七、二叉搜索树的实现

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _right;
	BSTreeNode<K>* _left;
	K _key;

	BSTreeNode(const K& key = K())
		:_right(nullptr)
		,_left(nullptr)
		,_key(key)
	{
	}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree()
		:_root(nullptr)
	{}

	BSTree(const BSTree<K>& tree)
	{
		_root = Copy(tree._root);
	}

	BSTree<K>& operator=(BSTree<K> tmp)
	{
		swap(_root, tmp._root);
		return *this;
	}

	~BSTree()
	{
		Destory(_root);
	}

	bool insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
		}
		else
		{
			Node* cur = _root;
			Node* parent = cur;
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}
			if (key > parent->_key)
			{
				parent->_right = new Node(key);
			}
			else
			{
				parent->_left = new Node(key);
			}
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	

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

	bool erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			//找到要被删的节点了
			else
			{
				//1、要删除的这个节点是叶子节点或度为1（可直接删除）
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}
				}
				else if(cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right = cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
				}
				//2、要删除的这个节点度为2（替换法）
				else
				{
					//找左树中的最大值或右树中的最小值与被删节点交换，再删除
					//找左树中的最大值
					Node* leftMax = cur->_left;
					Node* PLeftMax = cur;
					while (leftMax->_right)
					{
						PLeftMax = leftMax;
						leftMax = leftMax->_right;
					}
					
					swap(cur->_key, leftMax->_key);//交换值
					//删除leftMax
					if (PLeftMax->_right == leftMax)
					{
						if (leftMax->_right == nullptr)
						{
							PLeftMax->_right = leftMax->_left;
						}
						else
						{
							PLeftMax->_right = leftMax->_right;
						}
					}
					if (PLeftMax->_left == leftMax)
					{
						if (leftMax->_right == nullptr)
						{
							PLeftMax->_left = leftMax->_left;
						}
						else
						{
							PLeftMax->_left = leftMax->_right;
						}
					}
					cur = leftMax;
				}
				delete cur;
				return true;
			}
		}
		return false;
	}

	//-----------------------------------递归写法---------------------------------------
	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);
	}

private:
	bool _eraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _eraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _eraseR(root->_left, key);
		}
		else
		{
			Node* del = root;
			//找到了被删除节点
			//1、左为空或右为空或左右都为空
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			//2、左右都不为空
			else
			{
				//左树找最大值
				Node* LeftMax = root->_left;
				while (LeftMax->_right)
				{
					LeftMax = LeftMax->_right;
				}
				swap(root->_key, LeftMax->_key);
				

				//删除LeftMax节点
				return _eraseR(root->_left, key);
			}
			delete del;
			return true;
		}
	}

	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* Croot = new Node(root->_key);
		Croot->_left = Copy(root->_left);
		Croot->_right = Copy(root->_right);
		return Croot;
	}

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

	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;
		}
	}


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

	void _InOrder(Node* root)
	{
		//中序
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

private:
	Node* _root;
};
@Klay Thompson
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环实现二叉搜索树的查找与插入
07-19
本人用python实现了二叉搜索树的查找（递归与非递归）与插入（递归与非递归）和打印功能，并生成n个随机数插入二叉搜索树当中，中序遍历输出。学习数据结构的同学可以参考一下！！！
Java 实现二叉搜索树的查找、插入、删除、遍历
08-31
本文主要介绍了Java实现二叉搜索树的查找、插入、删除、遍历等内容。具有很好的参考价值，下面跟着小编一起来看下吧
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 5716
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉搜索树的查找与插入操作
weixin_43987915的博客
04-04 186
/* * 二叉搜索树 * * 定义 : * 对于一颗二叉树其 * 非空左子树的所有键值小于其根结点的值 * 非空右子树的所有键值大于其根结点的值 * 左右子树都是二叉搜索树 * * 操作 : * 查找 * 递归查找 * 迭代查找 * 插入 * 递归插入 * 迭代插入 * * * * */ #include <iostream> #include <stdio.h> #include
二叉查找树中的插入查找和删除
热门推荐
naget的博客
09-05 1万+
上一篇文中，通过二分查找，我们实现了对数级别的查找方案，但因为使用了数组这一数据结构，插入时需要移动大量的元素，导致插入动作任然很慢。为了减少移动的元素，我们这次使用链表，为了保持二分查找的效率，我们将二者结合起来——二叉查找树。 一个二叉查找树就是一个二叉树，每个节点上包含有一个键一个值一个指向左节点的链接一个指向右节点的链接（这个图中的数字代表键，值没有显示）。而且每个结点的键都大于其左...
二叉查找树（BST）｜搜索及插入操作
嗅探网的博客
08-30 658
假设我们要搜索数字，我们从根开始，然后我们将要搜索的值与根的值进行比较，如果相等，我们完成搜索，如果它更小，我们知道我们需要转到左子树，因为在二叉查找树中，左子树中的所有元素都较小，而右子树中的所有元素都较大。为了搜索一个值，如果我们有一个排序数组，我们可以通过二分查找法来进行搜索。在二分查找中，我们从搜索空间中的“n”个元素开始，如果中间元素不是我们正在寻找的元素，我们将搜索空间减少到“n/2”，以此类推我们不断缩小搜索空间，直到我们找到想要寻找的值，或者我们将搜索空间缩小到一个元素并停止搜索。.....
二叉搜索树的插入、查找、删除
m0_55752775的博客
01-14 873
二叉搜索树的插入、查找、删除
二叉搜索树详解--实现插入和删除
wtl666_6的博客
10-31 6680
二叉搜索树 bst树
二叉查找树的插入
实践求真知
08-02 1702
二叉查找树
二叉搜索树:查找,插入,删除操作
NIHANA_HR的博客
05-15 785
什么是二叉搜索树 二叉搜索树是由二叉树组织的,如下:和普通二叉树相比多了parent结点,这样可以匹配搜索二叉树性质方便实现相应的功能;二叉搜索树有那些性质呢: 对任何结点x,其左子树中的关键字最大不超过x.key,其右子树中的关键字最小不低于x.key. class Node { public: int key; node*left; node*right; node*parent; }; 我们可以使用中序遍历方法遍历这颗树,这样结果就是有序的 上图所示搜索二叉树中序遍历结果为:1
JAVA 二叉搜索树（查找 插入 删除）
m0_70343551的博客
01-26 691
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。3. cur 不是 root，cur 是 parent.right，则 parent.right = cur.left。2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.right。2. cur 不是 root，cur 是 parent.left，则 parent.left = cur.left。
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
下面小编就为大家分享一篇Java创建二叉搜索树,实现搜索,插入,删除的操作实例，具有很好的参考价值，希望对大家有所帮助
二叉搜索树 查找 构造 插入 删除
03-22
二叉搜索树 编写二叉搜索树类定义。在类定义中只包含构造、插入、输出3个函数的声明 编写二叉搜索树的插入算法 编写代码输出二叉搜索树。...二叉搜索树类定义中增加删除函数的声明，并编写删除算法
Python实现二叉搜索树BST的方法示例
09-18
主要介绍了Python实现二叉搜索树BST的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
[每日一题]169：找出最大的可达成数字
AngelDg的博客
05-21 213
题目要求得一个最大的整数 x，使其在不超过 t 次操作内变成与 num 相等的数字。每次操作可以选择将 x 增加或减少 1，同时可以选择将 num 增加或减少 1。返回所有可达成数字中的最大值。可以证明至少存在一个可达成数字。给你两个整数 num 和 t。
质数和约数
最新发布
2302_77099705的博客
05-21 694
最大公约数（Greatest Common Divisor）指两个或多个整数共有约数中最大的一个。也称最大公因数、最大公因子，a， b的最大公约数记为（a，b），同样的，a，b，c的最大 公约数记为（a，b，c），多个 整数的最大公约数也有同样的记号。求最大公约数有多种 方法，常见的有 质因数分解法、 短除法、 辗转相除法、 更相减损法。
算法刷题笔记 逆序对的数量（C++实现）
hanmo22357的博客
05-18 307
AcWing上的算法基础课题目 逆序对的数量 刷题笔记记录
【算法刷题day60】Leetcode：84. 柱状图中最大的矩形
qq_45022758的博客
05-21 178
暂无84. 柱状图中最大的矩形代码随想录解析。
P1135 奇怪的电梯
loongnoy的博客
05-17 275
大楼的每一层楼都可以停电梯，而且第 𝑖i 层楼（1≤𝑖≤𝑁1≤i≤N）上有一个数字 𝐾𝑖Ki​（0≤𝐾𝑖≤𝑁0≤Ki​≤N）。例如： 3,3,1,2,53,3,1,2,5 代表了 𝐾𝑖Ki​（𝐾1=3K1​=3，𝐾2=3K2​=3，……），从 11 楼开始。第一行为三个用空格隔开的正整数，表示 𝑁,𝐴,𝐵N,A,B（1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N）。对于 100%100% 的数据，1≤𝑁≤2001≤N≤200，1≤𝐴,𝐵≤𝑁1≤A,B≤N，0≤𝐾𝑖≤𝑁0≤Ki​≤N。
二叉搜索树查找c++代码
11-17
二叉搜索树是一种常见的数据结构，可以用于高效地查找、插入和删除元素。在二叉搜索树中，每个节点都有一个值，并且左子树中的所有节点的值都小于该节点的值，右子树中的所有节点的值都大于该节点的值。 要查找一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值