• 【数据结构】搜索二叉树(C++实现)

    目录

    一、二叉搜索树的概念

    二、二叉搜索树的实现

    2.1 节点的定义及构造

    2.2 树的结构及功能展示

    2.3 树的 Insert

    2.4 树的中序遍历

    2.4 树的 Find

    2.5 树的 Erase

    2.6 拷贝构造、赋值运算符重载、析构函数

    三、递归实现树的增删查 

    3.1 递归实现 FindR

    3.2 递归实现 InsertR

    3.3 递归实现 EraseR

    四、二叉树搜索树的应用

    4.1 key 模型

    4.2 key-value 模型

    五、二叉树搜索树的性能分析

    六、二叉搜索树(key、key-value)代码

    一、二叉搜索树的概念

    二叉搜索树又称二叉排序树，它或者是一棵空树 ，或者是具有以下性质的二叉树:
    • 若它的左子树不为空，则左子树上所有的节点的值都小于根节点的值。
    • 若它的右子树不为空，则右子树上所有的节点的值都大于根节点的值。
    • 它的左右子树也分别为二叉搜索树。

    二、二叉搜索树的实现

    2.1 节点的定义及构造

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

    注意：

    ①我们会不断的通过 key 创建树节点， new 出的对象会调用带参的构造函数。所以，我们定义好节点中的成员变量后还要书写好构造函数。

    ②因为树节点会频繁访问成员变量，所以我们要将其置为公有成员(public)，如果觉得麻烦，可以直接使用 struct 定义节点。

    1. template <class K>
    2. class BSTreeNode
    3. {	
    4. public:
    5. 	BSTreeNode* _left;
    6. 	BSTreeNode* _right;
    7. 	K _key;
    8.  
    9. 	//用 key 构造一个树节点
    10. 	BSTreeNode(const K& key)
    11. 		:_left(nullptr)
    12. 		,_right(nullptr)
    13. 		,_key(key)
    14. 	{}
    15. };

    2.2 树的结构及功能展示

    接下来看看 BSTree 类中的我们要实现的成员函数及变量定义。

    1. template <class K>
    2. 	class BSTree
    3. 	{
    4. 		typedef BSTreeNode Node;
    5.  
    6. 	private:
    7. 		Node* _root = nullptr;
    8.  
    9. 	public:
    10.         //默认成员函数
    11.         BSTree ();
    12.         BSTree (const K& key);
    13.         BSTree& operator=(BSTree Tree);
    14.         ~BSTree();
    15.         
    16. 		bool Insert(const K& key);
    17. 		void Inorder();
    18. 		bool find(const K& key);
    19. 		bool Erase(const K& key);
    20.         
    21. 		//递归实现   
    22. 		bool FindR(const K& key);
    23. 		bool InsertR(const K& key);
    24. 		bool EraseR(const K& key);
    25.     }

    2.3 树的 Insert

    首先，我们实现树的插入。我们要明确，这个插入要符合二叉搜索树的特性，即左子树的值小于根节点的值，右节点的值都大于根节点的值。

    共分为以下几种情况和步骤：

    1. 传入空树直接 new 一个节点，将其置为 root 。
    2. 找到 key 值该在的位置，如果 key 大于 当前节点的 _key，则往右走，小于则往左走。
    3. 如果 key 等于当前节点的 _key，直接返回 false。
    4. 直到 cur 走到空，此时 cur 指向的便是 key 应当存放的地方。
    5. 创建一个节点并链接到树中(链接到 parent 节点的左或右)
    1. 	bool Insert(const K& key)
    2. 		{
    3. 			//如果当前树为空
    4. 			if (_root == nullptr)
    5. 			{
    6. 				_root = new Node(key);
    7. 				return true;
    8. 			}
    9. 			Node* parent = nullptr;
    10. 			Node* cur = _root;
    11. 			//直到 cur 指向 nullptr
    12. 			while (cur)
    13. 			{
    14. 				//cur->_key 小于 key 走右子树
    15. 				if (cur->_key < key)
    16. 				{
    17. 					parent = cur;
    18. 					cur = cur->_right;
    19. 				}
    20. 				//cur->_key 小于  走左子树
    21. 				else if (cur->_key > key)
    22. 				{
    23. 					parent = cur;
    24. 					cur = cur->_left;
    25. 				}
    26. 				//cur->_key == key 不允许插入
    27. 				else
    28. 				{
    29. 					return false;
    30. 				}
    31. 			}
    32. 			//此时cur处于正确的位置。
    33. 			cur = new Node(key);
    34. 			//判断 key 应该在 parent 的左边还是右边
    35. 			if (parent->_key > key)
    36. 				parent->_left = cur;
    37. 			else
    38. 				parent->_right = cur;
    39. 			return true;
    40. 		}

    2.4 树的中序遍历

    插入完成后，接下来我们就测试一下我们的代码。

    因为搜索树的规律为，左子树<根节点<右子树。所以说我们只要先打印左子树，在打印根节点，最后打印右子树，就可以按顺序输出树中存放的 key 值。

    而这个顺序正好对应我们二叉树中的中序遍历。接下来我们就来实现一个中序遍历吧。

    类中的递归函数并不容易被调用。如果我们直接使用 root 作为函数的 Insert 的参数，就不得不将_root 变为 公有成员

    代码检测：

    2.4 树的 Find

    find 和 Insert 核心代码完全相同。

    1.     bool Find(const K& key)
    2. 		{
    3. 			Node* cur = _root;
    4. 			while (cur)
    5. 			{
    6. 				if (cur->_key > key)
    7. 				{
    8. 					cur = cur->_left;
    9. 				}
    10. 				else if (cur->_key
    11. 				{
    12. 					cur = cur->_right;
    13. 				}
    14. 				else
    15. 				{
    16. 					return true;
    17. 				}
    18. 			}
    19. 			return false;
    20. 		}

    效果检测：

    2.5 树的 Erase

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

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

    情况一和情况二非常好解决，其本质都属于左或右节点为空，当该节点只有一个孩子或无孩子时，直接让 parent 指向该节点子节点，然后将此节点移除出树。 

    我们先来解决前两种情况。其中有这几个点需要我们注意：

    1.删除的是根节点

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

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

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

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

    代码如下(情况1、2的解决方法)：

    1. bool _Erase(const K& key)
    2. {
    3. 	Node* parent = nullptr;
    4. 	Node* cur = _root;
    5. 	//找key
    6. 	while (cur)
    7. 	{
    8. 		if (cur->_key > key)
    9. 		{
    10. 			parent = cur;
    11. 			cur = cur->_left;
    12. 		}
    13. 		else if (cur->_key < key)
    14. 		{
    15. 			parent = cur;
    16. 			cur = cur->_right;
    17. 		}
    18. 		//找到存放 key的节点
    19. 		else
    20. 		{
    21. 			//key的左子树为空 所以父节点链接右子树
    22. 			if (cur->_left == nullptr)
    23. 			{
    24. 				//如果删除的是根节点，此时父节点指向为nullptr
    25. 				if (parent == nullptr)
    26. 				{
    27. 					//直接让_root指向下一个节点
    28. 					_root = _root->_right;
    29. 				}
    30. 				else
    31. 				{
    32. 					//判断应该链接到父节点的左还是右
    33. 					if (cur == parent->_left)
    34. 						parent->_left = cur->_right;
    35. 					else
    36. 						parent->_right = cur->_right;
    37. 				}
    38. 				delete cur;
    39. 			}
    40. 			//key的右子树为空 所以父节点链接左子树
    41. 			else if (cur->_right == nullptr)
    42. 			{
    43. 				//删除的为根节点的情况
    44. 				if (parent == nullptr)
    45. 				{
    46. 					_root = _root->_left;
    47. 				}
    48. 				else
    49. 				{
    50. 					//判断应当链接到父节点的左还是右
    51. 					if (cur == parent->_left)
    52. 					{
    53. 						parent->_left = cur->_left;
    54. 					}
    55. 					else
    56. 					{
    57. 						parent->_right = cur->_left;
    58. 					}
    59. 				}
    60. 				delete cur;
    61. 			}
    62. 			//删除节点左、右都不为空
    63. 			else
    64. 			{
    65. 				
    66. 			}
    67. 			return true;
    68. 		}
    69. 	}
    70. 	return false;
    71. }

    情况三采用的是替换法删除，我们观察下图，删除 3 的情况。 

    为什么会这样呢？我们结合搜索树的性质和中序遍历，中序遍历中打印根节点的上一个节点是左子树的最右节点，根节点的下一个节点是右子树的最左节点，这两个节点的值于根节点的值最相近，所以，这两个节点是替换根节点的最好节点，替换后能不破坏搜索树的结构。 

    我们把 3 看作根为一棵搜索树

    • 左子树的最大节点——左子树的最右节点，即 2
    • 右子树的最小节点——右子树的最左节点，即 4

    所以这里我们找右子树的最小节点进行替换。

    此时我们开始编写代码，不考虑一些特殊情况。

    1. //删除节点左、右都不为空
    2. 	else
    3.     {
    4. 		Node* min = cur->_right;
    5. 		while (cur->_right == nullptr)
    6. 		{
    7. 			min = min->_left;
    8. 		}
    9. 		swap(cur->_key, cur->_key);
    10. 		delete cur;
    11. 	}

     好的，接下来我们分析上面的代码会造成什么问题。

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

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

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

    解决问题2：

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

    所以我们要将minparent初始化为cur。如果删除8节点，min节点往下找右子树的最左节点，再让 parent 指向右子树的最左节点的右子树，此时就会破坏树的结构，如图：

     所以，我们还是要判断，如果 min 在 minparent 的左子树，就改变minparent的左子树；如果 min在minparent的右子树，就改变minparent的右子树。

     

     好的，这两个棘手的问题我们就顺利解决了，我们来看看整体的 Erase 代码。

    1. //删除
    2. bool _Erase(const K& key)
    3. {
    4. 	Node* parent = nullptr;
    5. 	Node* cur = _root;
    6. 	//找key
    7. 	while (cur)
    8. 	{
    9. 		if (cur->_key > key)
    10. 		{
    11. 			parent = cur;
    12. 			cur = cur->_left;
    13. 		}
    14. 		else if (cur->_key < key)
    15. 		{
    16. 			parent = cur;
    17. 			cur = cur->_right;
    18. 		}
    19. 		//找到存放 key的节点
    20. 		else
    21. 		{
    22. 			//key的左子树为空 所以父节点链接右子树
    23. 			if (cur->_left == nullptr)
    24. 			{
    25. 				//如果删除的是根节点，此时父节点指向为nullptr
    26. 				if (parent == nullptr)
    27. 				{
    28. 					//直接让_root指向下一个节点
    29. 					_root = _root->_right;
    30. 				}
    31. 				else
    32. 				{
    33. 					//判断应该链接到父节点的左还是右
    34. 					if (cur == parent->_left)
    35. 						parent->_left = cur->_right;
    36. 					else
    37. 						parent->_right = cur->_right;
    38. 				}
    39. 				delete cur;
    40. 			}
    41. 			//key的右子树为空 所以父节点链接左子树
    42. 			else if (cur->_right == nullptr)
    43. 			{
    44. 				//删除的为根节点的情况
    45. 				if (parent == nullptr)
    46. 				{
    47. 					_root = _root->_left;
    48. 				}
    49. 				else
    50. 				{
    51. 					//判断应当链接到父节点的左还是右
    52. 					if (cur == parent->_left)
    53. 					{
    54. 						parent->_left = cur->_left;
    55. 					}
    56. 					else
    57. 					{
    58. 						parent->_right = cur->_left;
    59. 					}
    60. 				}
    61. 				delete cur;
    62. 			}
    63. 			//删除节点左、右都不为空
    64. 			else
    65. 			{
    66. 				//指向cur，防止非法访问
    67. 				Node* minparent = cur;
    68. 				Node* min = cur->_right;
    69. 				while (min->_left != nullptr)
    70. 				{
    71. 					minparent = min;
    72. 					min = min->_left;
    73. 				}
    74. 				swap(cur->_key, min->_key);
    75. 				//解决野指针或min->right有子树的情况
    76. 				//minparent->_left = min->_right;
    77. 				//判断min在minparent的左或右
    78. 				if (minparent->_left == min)
    79. 					minparent->_left = min->_right;
    80. 				else
    81. 					minparent->_right = min->_right;
    82. 				delete min;
    83. 			}
    84. 			return true;
    85. 		}
    86. 	}
    87. 	return false;
    88. }

    好的，我们来测试一下代码。

    2.6 拷贝构造、赋值运算符重载、析构函数

    析构函数

    与普通的二叉树Destory代码几乎一样。

    构造与拷贝构造函数函数

    拷贝构造函数就是根据前序构造出一棵树，如下：

    注意，如果写了默认拷贝构造函数编译器就不会默认生成构造函数了，所以这里我们也要提供一个默认构造函数或者强制编译器为我们默认生成一个构造函数。如下：

     

    赋值运算符重载

    因为我们已经实现了拷贝构造函数，所以我们可以套用拷贝构造函数来实现赋值运算符重载。

     测试：

    三、递归实现树的增删查 

    3.1 递归实现 FindR

    实现递归版本的 Find ，总共分4步：

    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 。

    代码如下：

    1. //Find的递归版本
    2. bool FindR(const K& key)
    3. {
    4. 	return _FindR(_root, key);
    5. }
    6.  
    7. bool _FindR(const Node* root, const K& key)
    8. {
    9. 	if (root == nullptr)
    10. 		return false;
    11. 	if (root->_key < key)
    12. 	{
    13. 		_FindR(root->_right, key);
    14. 	}
    15. 	else if (root->_key > key)
    16. 	{
    17. 		_FindR(root->_left, key);
    18. 	}
    19. 	else
    20. 	{
    21. 		return true;
    22. 	}
    23. }

    3.2 递归实现 InsertR

    在实现了FindR之后，实现出InsertR应该不难，代码大致如下：

    1.  
    2. bool InsertR(const K& key)
    3. {
    4. 	return _InsertR(_root, key)
    5. }
    6.  
    7. bool _InsertR(const Node* root, const K& key)
    8. {
    9. 	if (root == nullptr)
    10. 	{
    11. 		root = new Node(key);
    12. 		return true;
    13. 	}
    14. 	if (root->_key < key)
    15. 	{
    16. 		return _InsertR(root->_right, key);
    17. 	}
    18. 	else if (root->_key > key)
    19. 	{
    20. 		return _InsertR(root->_left, key);
    21. 	}
    22. 	else
    23. 	{
    24. 		//已存在 key 不允许插入
    25. 		return false;
    26. 	}
    27. }

    可是，发现一个问题，这样的写法是无法修改外部实参的，即无法链入搜索树中，所以我们要采用引用传参或二级指针传参，这样才能实质修改外部的变量。

    root == nullptr 就将 key 链入树中，此时 root 为最后一个节点左或右子树的别名

     

    3.3 递归实现 EraseR

    递归删除的主题逻辑与上面大致相同。

    步骤如下：

    1.root == nullptr，则返回false，即未找到 key，删除失败

    2.如果root->_key 小于 key，递归走右子树，

    3.如果root->_key 大于 key，递归走左子树

    4.最后就是 root->key == key，则开始删除节点。

    1. bool _EraseR(Node* root, const K& key)
    2. {
    3. 	if (root == nullptr)
    4. 	{
    5. 		return false;
    6. 	}
    7. 	if (root->_key < key)
    8. 	{
    9. 		return _EraseR(root->_right, key);
    10. 	}
    11. 	else if (root->_key > key)
    12. 	{
    13. 		return _EraseR(root->_left, key);
    14. 	}
    15. 	//找到key，删除
    16. 	else
    17. 	{
    18. 	}
    19. }

    当已经找到key值，进行删除时

    1.如果左子树为空，则让root指向其右子树。如图：

     2.如果右子树为空，则让root指向左子树，如图：

    3.当左子树、右子树都不为空时，采用替换法删除，交换 key 值，然后删除被替换的节点。

     交换过后，我们要删除 key 节点此时要使用root->right再次调用 _EraseR，如果直接使用  _EraseR(key)，则会删除失败，因为树的结构已经被破坏。

    代码如下：

    1. bool EraseR(const K& key)
    2. {
    3. 	return _EraseR(root, key);
    4. }
    5. bool _EraseR(Node*& root, const K& key)
    6. {
    7. 	if (root == nullptr)
    8. 	{
    9. 		return false;
    10. 	}
    11. 	if (root->_key < key)
    12. 	{
    13. 		return _EraseR(root->_right, key);
    14. 	}
    15. 	else if (root->_key > key)
    16. 	{
    17. 		return _EraseR(root->_left, key);
    18. 	}
    19. 	//找到key，删除
    20. 	else
    21. 	{
    22.         //情况1、2要记录待删除的节点。
    23. 		Node* del = root;
    24. 		if (root->_left == nullptr)
    25. 		{
    26. 			root = root->_right;
    27. 		}
    28. 		else if (root->_right == nullptr)
    29. 		{
    30. 			root = root->_left;
    31. 		}
    32. 		//左右都有孩子
    33. 		else
    34. 		{
    35. 			Node* min = root->_right;
    36. 			while (min->_left)
    37. 			{
    38. 				min = min->_left;
    39. 			}
    40. 			swap(root->_key, min->_key);
    41. 			//这里不能直接调用erase,交换后，树的结构已经破坏，显示找不到key值
    42. 			//return EraseR(key); 
    43. 			return _EraseR(root->_right, key);
    44. 		}
    45. 		delete del;
    46. 		return true;
    47. 	}
    48. }

    四、二叉树搜索树的应用

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

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

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

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

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

    4.1 key 模型

    现在我们将二叉搜索树的K模型套入实际案例中，顺便练习编程能力。

    将要拼写的单词插入到二叉搜索树中，用户开始拼写单词，如果用户输入的单词在词库中并拼写正确，则输出"拼写正确"，否则输出"拼写错误"。代码如下：

    4.2 key-value 模型

    现在我们将二叉搜索树的 key-value 模型套入实际案例中，顺便练习编程能力。

    我们现在创建一个字典，用户输入英文，程序打印出中文。

    首先我们要创建 key-value 模型，然后将值插入，通过查找key，然后输出其value值。注意，如果是k-value模型，find的返回值就应为节点的指针。

    我们看看代码是如何书写的，并且尝试运行一下：

     通过key-value模型我们还可以实现统计次数的程序。

    例如我们往树中插入字符串，如果该字符串已存在，则++该字符串的计数。最后使用 Inorder 打印树中的元素，注意，要将Inorder中的输出语句带上value进行输出噢~

    代码及结果如下：

    五、二叉树搜索树的性能分析

    在实现完功能之后，我们来对二叉搜索树进行性能分析。

    问：搜索二叉树增删查的时间复杂度为多少？

    答：最坏的情况下为 O(h)  —— h为高度。

    为什么不是lgN，而是O(h) ，我们来看看如果树的形状是以下这几种情况的呢?

    对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度函数，即结点越深，比较次数越多。

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

    最优情况下：二叉搜索树为完全二叉树(或接近完全二叉树)，其平均比较次数为 lgN.

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

    所以说，二叉搜索树的效率在这种情况下跟O(N)几乎没有区别。其本质是不平衡的，所以后面我们要学习AVL树和红黑树来保持平衡。这样，搜索的效率就会极高。

    六、二叉搜索树(key、key-value)代码

    Key模型。

    1. //节点的定义
    2. template <class K>
    3. class BSTreeNode
    4. {
    5. public:
    6. 	BSTreeNode* _left;
    7. 	BSTreeNode* _right;
    8. 	K _key;
    9.  
    10. 	BSTreeNode(const K& key)
    11. 		:_left(nullptr)
    12. 		, _right(nullptr)
    13. 		, _key(key)
    14. 	{}
    15.  
    16. };
    17.  
    18. template <class K>
    19. class BSTree
    20. {
    21. 	typedef BSTreeNode Node;
    22. public:
    23. 	//C++11用法，作用：强制编译器生成默认的构造
    24. 	BSTree() = default;
    25.  
    26.  
    27. 	bool Insert(const K& key)
    28. 	{
    29. 		if (_root == nullptr)
    30. 		{
    31. 			_root = new Node(key);
    32. 			return true;
    33. 		}
    34. 		Node* parent = nullptr;
    35. 		Node* cur = _root;
    36. 		while (cur)
    37. 		{
    38. 			if (cur->_key < key)
    39. 			{
    40. 				parent = cur;
    41. 				cur = cur->_right;
    42. 			}
    43. 			else if (cur->_key > key)
    44. 			{
    45. 				parent = cur;
    46. 				cur = cur->_left;
    47. 			}
    48. 			else
    49. 			{
    50. 				return false;
    51. 			}
    52. 		}
    53. 		cur = new Node(key);
    54. 		if (parent->_key > key)
    55. 			parent->_left = cur;
    56. 		else
    57. 			parent->_right = cur;
    58. 		return true;
    59. 	}
    60.  
    61. 	void Inorder()
    62. 	{
    63. 		_Inorder(_root);
    64. 		cout << endl;
    65. 	}
    66.  
    67. 	bool Find(const K& key)
    68. 	{
    69. 		Node* cur = _root;
    70. 		while (cur)
    71. 		{
    72. 			if (cur->_key > key)
    73. 			{
    74. 				cur = cur->_left;
    75. 			}
    76. 			else if (cur->_key < key)
    77. 			{
    78. 				cur = cur->_right;
    79. 			}
    80. 			else
    81. 			{
    82. 				return true;
    83. 			}
    84. 		}
    85. 		return false;
    86. 	}
    87.  
    88. 	bool _Erase(const K& key)
    89. 	{
    90. 		Node* parent = nullptr;
    91. 		Node* cur = _root;
    92. 		while (cur)
    93. 		{
    94. 			if (cur->_key > key)
    95. 			{
    96. 				parent = cur;
    97. 				cur = cur->_left;
    98. 			}
    99. 			else if (cur->_key < key)
    100. 			{
    101. 				parent = cur;
    102. 				cur = cur->_right;
    103. 			}
    104. 			else
    105. 			{
    106. 				if (cur->_left == nullptr)
    107. 				{
    108. 					if (parent == nullptr)
    109. 					{
    110. 						_root = _root->_right;
    111. 					}
    112. 					else
    113. 					{
    114. 						if (cur == parent->_left)
    115. 							parent->_left = cur->_right;
    116. 						else
    117. 							parent->_right = cur->_right;
    118. 					}
    119. 					delete cur;
    120. 				}
    121. 				else if (cur->_right == nullptr)
    122. 				{
    123. 					if (parent == nullptr)
    124. 					{
    125. 						_root = _root->_left;
    126. 					}
    127. 					else
    128. 					{
    129. 						if (cur == parent->_left)
    130. 						{
    131. 							parent->_left = cur->_left;
    132. 						}
    133. 						else
    134. 						{
    135. 							parent->_right = cur->_left;
    136. 						}
    137. 					}
    138. 					delete cur;
    139. 				}
    140. 				else
    141. 				{
    142. 					Node* minparent = cur;
    143. 					Node* min = cur->_right;
    144. 					while (min->_left != nullptr)
    145. 					{
    146. 						minparent = min;
    147. 						min = min->_left;
    148. 					}
    149. 					swap(cur->_key, min->_key);
    150. 					if (minparent->_left == min)
    151. 						minparent->_left = min->_right;
    152. 					else
    153. 						minparent->_right = min->_right;
    154. 					delete min;
    155. 				}
    156. 				return true;
    157. 			}
    158. 		}
    159. 		return false;
    160. 	}
    161. 	bool FindR(const K& key)
    162. 	{
    163. 		return _FindR(_root, key);
    164. 	}
    165.  
    166. 	bool InsertR(const K& key)
    167. 	{
    168. 		return _InsertR(_root, key);
    169. 	}
    170.  
    171. 	bool EraseR(const K& key)
    172. 	{
    173. 		return _EraseR(_root, key);
    174. 	}
    175. 	~BSTree()
    176. 	{
    177. 		_Destory(_root);
    178. 	}
    179.  
    180. 	BSTree(const BSTree& t)
    181. 	{
    182. 		_root = _Copy(t._root);
    183. 	}
    184.  
    185. 	BSTree& operator=(BSTree t)
    186. 	{
    187. 		swap(t._root, _root);
    188. 		return *this;
    189. 	}
    190.  
    191.  
    192. private:
    193. 	Node* _Copy(Node* root)
    194. 	{
    195. 		if (root == nullptr)
    196. 		{
    197. 			return nullptr;
    198. 		}
    199. 		Node* copyRoot = new Node(root->_key);
    200. 		copyRoot->_left = _Copy(root->_left);
    201. 		copyRoot->_right = _Copy(root->_right);
    202. 		return copyRoot;
    203. 	}
    204.  
    205. 	void _Destory(Node* root)
    206. 	{
    207. 		if (root)
    208. 		{
    209. 			_Destory(root->_left);
    210. 			_Destory(root->_right);
    211. 			delete root;
    212. 		}
    213. 	}
    214. 	bool _EraseR(Node*& root, const K& key)
    215. 	{
    216. 		if (root == nullptr)
    217. 		{
    218. 			return false;
    219. 		}
    220. 		if (root->_key < key)
    221. 		{
    222. 			return _EraseR(root->_right, key);
    223. 		}
    224. 		else if (root->_key > key)
    225. 		{
    226. 			return _EraseR(root->_left, key);
    227. 		}
    228. 		//找到key，删除
    229. 		else
    230. 		{
    231. 			Node* del = root;
    232. 			if (root->_left == nullptr)
    233. 			{
    234. 				root = root->_right;
    235. 			}
    236. 			else if (root->_right == nullptr)
    237. 			{
    238. 				root = root->_left;
    239. 			}
    240. 			//左右都有孩子
    241. 			else
    242. 			{
    243. 				Node* min = root->_right;
    244. 				while (min->_left)
    245. 				{
    246. 					min = min->_left;
    247. 				}
    248. 				swap(root->_key, min->_key);
    249. 				//这里不能直接调用erase,交换后，树的结构已经破坏，显示找不到key值
    250. 				return _EraseR(root->_right, key);
    251. 			}
    252. 			delete del;
    253. 			return true;
    254. 		}
    255. 	}
    256.  
    257.  
    258. 	//传引用
    259. 	bool _InsertR(Node*& root, const K& key)
    260. 	{
    261. 		if (root == nullptr)
    262. 		{
    263. 			root = new Node(key);
    264. 			return true;
    265. 		}
    266. 		if (root->_key < key)
    267. 		{
    268. 			return _InsertR(root->_right, key);
    269. 		}
    270. 		else if (root->_key > key)
    271. 		{
    272. 			return _InsertR(root->_left, key);
    273. 		}
    274. 		else
    275. 		{
    276. 			//已存在 key 不允许插入
    277. 			return false;
    278. 		}
    279. 	}
    280.  
    281.  
    282. 	bool _FindR(const Node* root, const K& key)
    283. 	{
    284. 		if (root == nullptr)
    285. 			return false;
    286. 		if (root->_key < key)
    287. 		{
    288. 			_FindR(root->_right, key);
    289. 		}
    290. 		else if (root->_key > key)
    291. 		{
    292. 			_FindR(root->_left, key);
    293. 		}
    294. 		else
    295. 		{
    296. 			return true;
    297. 		}
    298.  
    299. 	}
    300.  
    301. 	void _Inorder(Node* root)
    302. 	{
    303. 		if (root)
    304. 		{
    305. 			_Inorder(root->_left);
    306. 			cout << root->_key << " ";
    307. 			_Inorder(root->_right);
    308. 		}
    309. 	}
    310.  
    311. 	Node* _root = nullptr;
    312. };

    Key-Value模型，Find、Insert函数做出相应修改，并删除了部分函数

    1. class BSTreeNode
    2. {
    3. public:
    4. 	BSTreeNode* _left;
    5. 	BSTreeNode* _right;
    6. 	K _key;
    7. 	Value _value;
    8. 	BSTreeNode(const K& key, const Value& value)
    9. 		:_left(nullptr)
    10. 		, _right(nullptr)
    11. 		, _key(key)
    12. 		, _value(value)
    13. 	{}
    14.  
    15. };
    16.  
    17. template <class K, class V>
    18. class BSTree
    19. {
    20. 	typedef BSTreeNode Node;
    21. public:
    22. 	bool Insert(const K& key, const V& value)
    23. 	{
    24. 		if (_root == nullptr)
    25. 		{
    26. 			_root = new Node(key, value);
    27. 			return true;
    28. 		}
    29. 		Node* parent = nullptr;
    30. 		Node* cur = _root;
    31. 		while (cur)
    32. 		{
    33. 			if (cur->_key < key)
    34. 			{
    35. 				parent = cur;
    36. 				cur = cur->_right;
    37. 			}
    38. 			else if (cur->_key > key)
    39. 			{
    40. 				parent = cur;
    41. 				cur = cur->_left;
    42. 			}
    43. 			else
    44. 			{
    45. 				return false;
    46. 			}
    47. 		}
    48. 		cur = new Node(key, value);
    49. 		if (parent->_key > key)
    50. 			parent->_left = cur;
    51. 		else
    52. 			parent->_right = cur;
    53. 		return true;
    54. 	}
    55.  
    56.  
    57. 	void Inorder()
    58. 	{
    59. 		_Inorder(_root);
    60. 		cout << endl;
    61. 	}
    62.  
    63. 	Node* Find(const K& key)
    64. 	{
    65. 		Node* cur = _root;
    66. 		while (cur)
    67. 		{
    68. 			if (cur->_key > key)
    69. 			{
    70. 				cur = cur->_left;
    71. 			}
    72. 			else if (cur->_key < key)
    73. 			{
    74. 				cur = cur->_right;
    75. 			}
    76. 			else
    77. 			{
    78. 				return cur;
    79. 			}
    80. 		}
    81. 		return nullptr;
    82. 	}
    83.  
    84. private:
    85. 	void _Inorder(Node* root)
    86. 	{
    87. 		if (root)
    88. 		{
    89. 			_Inorder(root->_left);
    90. 			cout << root->_key << ":" << root->_value << endl;
    91. 			_Inorder(root->_right);
    92. 		}
    93. 	}
    94. 	Node* _root = nullptr;
    95. };

  • 相关阅读:
    图像处理7-图像增强
    Linux学习笔记
    循环神经网络 - 循环神经网络的简洁实现
    Java毕业设计之基于SSM实现的宠物销售网站
    高效开发与设计：提效Spring应用的运行效率和生产力 | 京东云技术团队
    2024年第16周技术复盘
    比科奇推出5G小基站开放式RAN射频单元的高性能低功耗SoC
    【数据结构笔记03】数据结构之线性表的链式表示和实现（双向链表、循环链表）
    JSP 实习管理系统myeclipse开发mysql数据库网页模式java编程网页设计
    看懂半年报里的“宝藏指标”：华大基因加大研发投入酝酿蝶变
  • 原文地址：https://blog.csdn.net/Brant_zero/article/details/127657063