【C++】二叉树进阶之二叉搜索树

news2024/11/19 3:26:18

> 作者简介：დ旧言~，目前大二，现在学习Java，c，c++，Python等
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：熟练掌握二叉搜索树，能自己模拟实现二叉搜索树

> 毒鸡汤：不断的努力，不断的去接近梦想，越挫越勇，吃尽酸甜苦辣，能够抵御寒冬，也能够拥抱春天，这样的才叫生活。

> 望小伙伴们点赞👍收藏✨加关注哟💕💕 

🌟前言  

前期呢我们学习了简单二叉树，这个简单真的是一点都不简单呀，如果大家对二叉树的知识点忘记的小伙伴们可以看看这篇博客二叉树的实现-CSDN博客，这篇博客不单单是二叉树的进阶，这次的知识是为了后面的map和set以及红黑树...打下基础，c++的学习也是上了一个层次，进入今天的主题----二叉树进阶之二叉搜索树。

⭐主体

学习二叉树进阶之二叉搜索树咱们按照下面的图解：

🌙二叉搜索树基本概念

💫基本概念

二叉搜索树（Binary Search Tree），（又：二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉搜索树。二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。 

💫基本结构

二叉搜索树是能够高效地进行如下操作的数据结构。

  1. 插入一个数值
  2. 查询是否包含某个数值
  3. 删除某个数值

💫基本性质

设x是二叉搜索树中的一个结点。如果y是x左子树中的一个结点，那么y.key≤x.key。如果y是x右子树中的一个结点，那么y.key≥x.key。

在二叉搜索树中：

  1. 若任意结点的左子树不空，则左子树上所有结点的值均不大于它的根结点的值。
  2. 若任意结点的右子树不空，则右子树上所有结点的值均不小于它的根结点的值。
  3. 任意结点的左、右子树也分别为二叉搜索树

1.这也就说明二叉搜索树的中序遍历（左 根 右）是升序的。

2.如果共有n个元素，那么平均每次操作需要O(logn)的时间。

 🌙二叉搜索树模拟实现

基本框架：

template <class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
 
	private:
		Node* _root = nullptr;
 
	public:
        //默认成员函数
        BSTree ();
        BSTree (const K& key);
        BSTree& operator=(BSTree Tree);
        ~BSTree();
        
		bool Insert(const K& key);
		void Inorder();
		bool find(const K& key);
		bool Erase(const K& key);
        
		//递归实现   
		bool FindR(const K& key);
		bool InsertR(const K& key);
		bool EraseR(const K& key);
    }

💫二叉搜索树节点创建

创建树之前要先定义好节点，跟之前普通链式二叉树没有什么区别。

代码实现：

// 对每个结点初始化
template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node; // 重命名

	Node* _left;  // 左子树
	Node* _right; // 右子树
	K _key;       // 二叉搜索树节点元素的值

	BSTreeNode(const K& key) // 初始化列表，成员变量初始化
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};

拓展分析：

  • 我们会不断的通过 key 创建树节点， new 出的对象会调用带参的构造函数。所以，我们定义好节点中的成员变量后还要书写好构造函数。
  • 因为树节点会频繁访问成员变量，所以我们要将其置为公有成员(public)，如果觉得麻烦，可以直接使用 struct 定义节点。

💫二叉搜索树构造函数

二叉搜索树这个类只要存入二叉树的根节点就可以了

代码实现：

// 强制生成默认构造函数
BSTree() = default;

拓展分析：

这里加入default关键字是让编译器强制生成默认构造函数，因为等会我们要写拷贝构造，根据C++的类和对象的知识，我们只要显式的写一个构造函数，编译器就不会生成默认构造函数

💫二叉搜索树查找函数

二叉搜索树，左树比根小，右树比根大我们可以根据这个特性去寻找，走到空的位置还没有找到，证明该树中没有该元素。

1）非递归

代码实现：

// 查找函数
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;
}

拓展分析：

这里采用左树比根小，右树比根大的特性来实现代码。

2）递归

步骤拆分：

  1. 如果 root 指向为 nullptr ，说明未找到 key 值
  2. 如果 key 大于 root->key，说明 key 在 root 的右边，使用root->right继续递归。
  3. 如果 key 小于 root->key，说明 key 在 root 的左边，使用root->left继续递归。
  4. 最后就是 key==root->key 的情况，返回 true 。

代码实现：

// 递归版本
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;
	}
}

拓展分析：

递归这里有一点小问题，因为在C++类中，实现递归是有一些问题的，因为我们把根直接封在类中了，函数根本就不需要参数就可以访问根节点，但是我们的递归函数需要参数来控制向哪棵树递归

💫二叉搜索树插入函数

对于链式结构来说，我们直接向这个空节点赋值，表面上是链接了，实际上根本没有链接上，因为我们遍历所使用的节点是一个临时变量，出了作用域就会自动销毁，所以根本没有链接上，所以我们还要记住最后走到的空节点的父节点，用父节点来链接新插入的节点。

1）非递归

步骤拆分：

  1. 传入空树直接 new 一个节点，将其置为 root 。
  2. 找到 key 值该在的位置，如果 key 大于 当前节点的 _key，则往右走，小于则往左走。
  3. 如果 key 等于当前节点的 _key，直接返回 false。
  4. 直到 cur 走到空，此时 cur 指向的便是 key 应当存放的地方。
  5. 创建一个节点并链接到树中(链接到 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;
			cut = cur->_left;
		}
		else if (cur->_key > key) // 比它大走右子树
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(key); // 开始链接
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

	return true;
}
2）递归
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;
	}
}

拓展分析：

💫二叉搜索树节点删除

问题剖析：

Erase 删除分为以下三种情况：

  1. 删除节点为叶子节点
  2. 删除节点有一个子节点
  3. 删除节点有两个子节点

第一点和第二点可以归纳为一点，而第二点是这个三点最为复杂的。

问题分析：

①：删除节点为叶子节点    &&    删除节点有一个子节点

分析：其本质都属于左或右节点为空，当该节点只有一个孩子或无孩子时，直接让 parent 指向该节点子节点，然后将此节点移除出树。 

1.删除的是根节点

如果parent指向的是nullptr，则直接让_root后移动即可。

2. 链接时，应该链接到父亲的左还是右。

如果parent的左边是待删节点，即parent->left==cur，则将cur的右边链接到parent的左边

如果parent的右边是待删节点，即parent->right==cur，将cur的右边链接到parent的右边

①：删除节点有两个子节点

分析：采用的是替换法删除，我们要删除3，我们知道cur的右子树中最左边的节点的值是与cur节点的值是最接近的，所以我们交换3和4，这样就转换为删除叶子节点了，这样就会把问题的难度降低。

1.此时 6 节点的_left 仍然指向原来的 4 节点，出现野指针的问题。并且如果 4 节点还有右子树呢？如图：

解决方案：我们的方法是仍要记录下min的父节点，让父节点指向 min->right，此时无论min->right有子树还是min->right==nullptr，都可以很好的解决该问题，

2. 无法删除根节点(8)

解决方案：删除8节点，此时 min 指向了cur->right，min ->left 为空，没有进入循环，导致minparent 为空指针，指向 minparent->_left = min->right;出现非法访问。

1）非递归

代码实现：

// 删除节点
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;
}
2）递归

代码实现：

// 递归版本
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;
		if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else
		{
			Node* rightMin = root->_right;
			while (rightMin->_left)
			{
				rightMin = rightMin->_left;
			}

			swap(root->_key, rightMin->_key);

			return _EraseR(root->_right, key);
		}

		delete del;
		return true;
	}
}

💫二叉搜索树拷贝构造

拷贝构造，我们可以参考前面的二叉树重建，直接递归解决，所以我们让二叉搜索树的拷贝构造调用我们的_Copy函数。

// 拷贝构造
BSTree(const BSTree<K>& t)
{
	_root = Copy(t.root);  // 调用拷贝构造
}

// 拷贝构造
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; // 返回根
}

💫二叉搜索树operator=

operator=我们采用现代写法，传参时会调用拷贝构造，我们直接将形参与我们当前对象交换。

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

💫二叉搜索树析构函数

析构函数也要递归实现，采用后序遍历，一个一个节点的删除

// 析构函数
~BSTree()
{
	Destroy(_root); // 调用析构函数
}

// 析构函数
void Destroy(Node* root) // 采用递归的形式
{
	if (root == nullptr)
		return;

	Destroy(root->_left);
	Destroy(root->right);
	delete root;
}

 🌙二叉搜索树应用场景

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

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

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

2.KV模型：每一个关键码 key ，都有与之对应的值 value，即<key，value>的键值对。该种方法式在现实生活中非常常见：

  • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word,chinese>就构成一种键值对；
  • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现的次数就是<world,count>，就够成一种键值对。

代码实现：

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

🌙全部代码

namespace lyk
{
	// 对每个结点初始化
	template<class K>
	struct BSTreeNode
	{
		typedef BSTreeNode<K> Node; // 重命名

		Node* _left;  // 左子树
		Node* _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;

		// 拷贝构造
		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t.root);  // 调用拷贝构造
		}

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

		// 析构函数
		~BSTree()
		{
			Destroy(_root); // 调用析构函数
		}
	
		// 插入结点
		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;
					cut = cur->_left;
				}
				else if (cur->_key > key) // 比它大走右子树
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			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->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				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->_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;
		}

		// 这样方便调用
		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:
		// 析构函数
		void Destroy(Node* root) // 采用递归的形式
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->right);
			delete root;
		}

		// 拷贝构造
		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; // 返回根
		}

		// 递归版本
		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;
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					Node* rightMin = root->_right;
					while (rightMin->_left)
					{
						rightMin = rightMin->_left;
					}

					swap(root->_key, rightMin->_key);

					return _EraseR(root->_right, key);
				}

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

		// 递归版本
		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;
			}
		}

		// 中序遍历
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr

	};

}

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

🌟结束语

       今天内容就到这里啦，时间过得很快，大家沉下心来好好学习，会有一定的收获的，大家多多坚持，嘻嘻，成功路上注定孤独，因为坚持的人不多。那请大家举起自己的小手给博主一键三连，有你们的支持是我最大的动力💞💞💞，回见。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1505784.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

每日一题-合成两个有序链表

每日一题-合成两个有序链表

&#x1f308;个人主页: 会编辑的果子君 &#x1f4ab;个人格言:“成为自己未来的主人~” 以上是题目信息&#xff1a; 下面是解答过程 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ typedef struct Lis…
阅读更多...
【C#语言入门】17. 事件详解（上）

【C#语言入门】17. 事件详解（上）

【C#语言入门】17. 事件详解&#xff08;上&#xff09; 一、初步了解事件 定义&#xff1a;单词Event&#xff0c;译为“事件” 通顺的解释就是**“能够发生的什么事情”**&#xff0c;例如&#xff0c;“苹果”不能发生&#xff0c;但是“公司上市”这件事能发生。在C#中事…
阅读更多...
Android 完整SDK项目中添加对应的JNI与底层通信

Android 完整SDK项目中添加对应的JNI与底层通信

安卓应用发消息给底层 近日需要写一个安卓app和底层发消息&#xff0c;这就涉及到java如何到c层的一个逻辑&#xff0c;app已经写好&#xff0c;就差发个消息了。至于如何对接底层&#xff0c;得和写底层的人进一步沟通&#xff0c;本文笔者只写从java层通信到cpp&#xff0c;…
阅读更多...
RabbitMQ - 05 - Direct交换机

RabbitMQ - 05 - Direct交换机

部署demo项目 通过消息队列demo项目进行练习 相关配置看此贴 http://t.csdnimg.cn/hPk2T 注意 生产者消费者的yml文件也要配置好 什么是Direct交换机 Direct 交换机是 AMQP&#xff08;高级消息队列协议&#xff09;中的一种交换机类型&#xff0c;它根据消息的路由键&am…
阅读更多...
【微服务】SpringBoot整合Resilience4j使用详解

【微服务】SpringBoot整合Resilience4j使用详解

目录 一、前言 二、熔断器出现背景 2.1 几个核心概念 2.1.1 熔断 2.1.2 限流 2.1.3 降级 2.2 为什么会出现熔断器 2.3 断路器介绍 2.3.1 断路器原理 三、Resilience4j介绍 3.1 Resilience4j概述 3.1.1 Resilience4j是什么 3.1.2 Resilience4j功能特性 3.2 Resilie…
阅读更多...
巨型犰狳优化算法（Giant Armadillo Optimization，GAO）的无人机三维路径规划（MATLAB）

巨型犰狳优化算法（Giant Armadillo Optimization，GAO）的无人机三维路径规划（MATLAB）

一、无人机路径规划模型介绍 无人机三维路径规划是指在三维空间中为无人机规划一条合理的飞行路径，使其能够安全、高效地完成任务。路径规划是无人机自主飞行的关键技术之一，它可以通过算法和模型来确定无人机的航迹，以避开障碍物、优化飞行时间和节省能量消耗。 二、算法介…
阅读更多...
javase day01笔记

javase day01笔记

第一天课堂笔记 Java第三代高级语言中的面向对象的语言 b/s 浏览器/服务器c/s 客户端/服务端 1991年詹姆斯高斯林在sun公司开发的Java 常用的dos命令 磁盘操作系统&#xff1a;dos win &#xff0b; r -》 cmd dos命令 切换盘符&#xff1a;直接输入对应盘符目录操作&#x…
阅读更多...
【R包开发：入门】 简介+ 包的结构

【R包开发：入门】 简介+ 包的结构

简介 本书的目的是教你如何开发包&#xff0c;以便你可以写出自己的包&#xff0c;而不只是使用别人的包。 为什么要写一个包&#xff1f; 一个令人信服的理由是&#xff0c;你想要与他人分享代码。把你的代码打成一个包&#xff0c;可以方便他人使用&#xff0c;因为他们像你…
阅读更多...
vue中性能优化

vue中性能优化

目录 1. 编码优化 2. 源码优化 3. 打包优化 4. 利用 Vue Devtools 总结 Vue.js 作为一个强大的前端框架&#xff0c;提供了丰富的功能和工具来帮助开发者构建高效的 Web 应用。然而&#xff0c;在开发过程中&#xff0c;性能优化仍然是一个需要关注的问题。以下是对 Vue.j…
阅读更多...
高级IO【select、poll、epoll】

高级IO【select、poll、epoll】

高山仰止&#xff0c;景行行止 文章目录 五种IO模型阻塞I/O非阻塞I/OI/O复用信号驱动I/O异步I/O 同步通信与异步通信同步通信异步通信 非阻塞IO基于fcntl实现setNonblock函数注意事项 IO多路转接—select文件描述符集合timeval结构调用过程返回值缺点和局限性 IO多路转接—poll…
阅读更多...
Java共享问题 、synchronized 线程安全分析、Monitor、wait/notify

Java共享问题 、synchronized 线程安全分析、Monitor、wait/notify

文章目录 1.共享带来的问题1.1 临界区 Critical Section1.2 竞态条件 Race Condition 2. synchronized语法及理解2.1 方法上的 synchronized 3.变量的线程安全分析3.1.成员变量和静态变量是否线程安全&#xff1f;3.2.局部变量是否线程安全&#xff1f;3.2.1 局部变量线程安全分…
阅读更多...
三阶导数在生活中应用

三阶导数在生活中应用

“鲍威尔还表示&#xff0c;美联储将在某个时候放慢&#xff08;利率&#xff09;加息步伐” 这是参考三阶导数&#xff08;贷款义务基础&#xff0c;利率一阶导数&#xff0c;利率变化二阶导数&#xff0c;利率变化速度三阶导数&#xff09;。 是否还有其他有趣的例子&#…
阅读更多...
算法详解——leetcode150（逆波兰表达式）

算法详解——leetcode150（逆波兰表达式）

欢迎来看博主的算法讲解 博主ID&#xff1a;代码小豪 文章目录 逆波兰表达式逆波兰表达式的作用代码将中缀表达式转换成后缀表达式文末代码 逆波兰表达式 先来看看leetcode当中的原题 大多数人初见逆波兰表达式的时候大都一脸懵逼&#xff0c;因为与平时常见的表达式不同&am…
阅读更多...
华为配置DHCP Snooping防止DHCP Server仿冒者攻击示例

华为配置DHCP Snooping防止DHCP Server仿冒者攻击示例

配置DHCP Snooping防止DHCP Server仿冒者攻击示例 组网图形 图1 配置DHCP Snooping防止DHCP Server仿冒者攻击组网图 DHCP Snooping简介配置注意事项组网需求配置思路操作步骤配置文件 DHCP Snooping简介 在一次DHCP客户端动态获取IP地址的过程中&#xff0c;DHCP Snoopi…
阅读更多...
基于Vue的娱讯移动端APP前端设计与实现

基于Vue的娱讯移动端APP前端设计与实现

目 录 摘 要 Abstract 引 言 1绪论 1.1课题背景及目的 1.1.1移动端APP发展简介 3 1.1.2移动端APP的优势 3 1.2前端开发相关技术 1.2.1前端开发工具介绍 3 1.2.2 前端开发相关技术介绍 4 1.3本章小结 2系统分析 2.1功能需求分析 2.2系统工作流程 2.3本章小结 3系统设…
阅读更多...
Linux 之七：Linux 防火墙 和进程管理

Linux 之七：Linux 防火墙 和进程管理

防火墙 查看防火墙 查看 Centos7 的防火墙的状态 sudo systemctl status firewalld。 查看后&#xff0c;看到active(running)就意味着防火墙打开了。 关闭防火墙&#xff0c;命令为&#xff1a; sudo systemctl stop firewalld。 关闭后查看是否关闭成功&#xff0c;如果…
阅读更多...
python的scripts文件夹作用

python的scripts文件夹作用

Windows系统&#xff1a; Scripts文件夹通常位于Python的安装目录下&#xff0c;如C:\Python\Scripts。该文件夹内包含了各种有用的工具&#xff0c;例如pip、virtualenv等&#xff0c;这些工具有助于管理和配置Python环境和依赖包。 Linux系统&#xff1a; 在Linux系统中&…
阅读更多...
【大厂AI课学习笔记NO.69】使用开源管理仓库

【大厂AI课学习笔记NO.69】使用开源管理仓库

了解了开源框架&#xff0c;开源项目&#xff0c;今天来学习开源管理仓库。 我们先说Git&#xff0c;开源的版本管理分布式系统。 GitHub&#xff0c;则是世界上最大的代码托管平台&#xff0c;面向开源和私有项目托管。 有的人总是分不清这两个&#xff0c;其实一个是版本管…
阅读更多...
凌鲨微应用架构

凌鲨微应用架构

微应用是静态网页加上凌鲨提供的扩展能力而形成的一种应用&#xff0c;主要特点是开发便捷&#xff0c;安全。 微应用架构 组件说明 名称 说明 微应用 webview窗口&#xff0c;显示web服务器上的页面 接口过滤器 根据权限配置,屏蔽非授权接口访问 接口提供者 tauri注入…
阅读更多...
循序渐进丨MogDB 数据库特性之动态数据脱敏机制

循序渐进丨MogDB 数据库特性之动态数据脱敏机制

数据脱敏是行之有效的数据库隐私保护方案之一&#xff0c;可以在一定程度上限制非授权用户对隐私数据的窥探。动态数据脱敏机制是一种通过定制化脱敏策略来实现对隐私数据保护的技术&#xff0c;可以在保留原始数据的前提下有效地解决非授权用户对敏感信息访问的问题。当管理员…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023