• 【C++】搜索二叉树底层实现

    目录

    一，概念

    二，实现分析

    1.  插入

    （1.）非递归版本 

     （2.）递归版本

     2. 打印搜索二叉树

    3.查找函数

    （1.）非递归版本

    （2.）递归版本

    4. 删除函数（重难点） 

    易错点分析，包你学会

    （1.）删除目标，没有左右孩子

    （2.）删除目标，只有一个孩子

    （3.）删除目标，有两个孩子

    代码

    （1.）非递归版本 

    （2.）递归版本

    5. 析构函数

    6.拷贝构造 

     三，应用

     四，搜索二叉树的缺陷及优化

    五，代码汇总

    结语

    一，概念

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

    为啥又被称作二叉排序树呢？ 当该树被层序遍历时，就是升序。

    二，实现分析

    实验例子：

    int a[] = {8, 3, 1, 10, 6, 4, 5, 7, 14, 13}; 

    1.  插入

    （1.）非递归版本 

    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
    b、最多查找高度次，走到到空，还没找到，这个值不存在。

     比较简单这里就直接放代码：

    1. template <class K>
    2. class BinarySeaTree_node
    3. {
    4. 	typedef BinarySeaTree_node BST_node;
    5. public:
    6. 	BinarySeaTree_node(const K& val)
    7. 		: _val(val)
    8. 		,_left(nullptr)
    9. 		,_right(nullptr)
    10. 	{}
    11.  
    12. 	K _val;
    13. 	BST_node* _left;
    14. 	BST_node* _right;
    15. };
    16.  
    17.  
    18. template <class T>
    19. class BSTree
    20. {
    21. 	typedef BinarySeaTree_node BST_node;
    22. private:
    23. 	BST_node* root = nullptr;
    24.  
    25. public:
    26. 	bool Insert(const T& val)
    27. 	{
    28. 		BST_node* key = new BST_node(val);
    29. 		BST_node* cur = root;
    30. 		BST_node* parent = nullptr;
    31. 		while (cur)
    32. 		{
    33. 			if (key->_val < cur->_val)
    34. 			{
    35. 				parent = cur;
    36. 				cur = cur->_left;
    37. 			}
    38. 			else if (key->_val > cur->_val)
    39. 			{
    40. 				parent = cur;
    41. 				cur = cur->_right;
    42. 			}
    43. 			else
    44. 			{
    45. 				return 0;
    46. 			}
    47. 		}
    48.  
    49. 		// 查询好位置后，建立链接
    50. 		if (!root)
    51. 		{
    52. 			root = key;
    53. 			return 0;
    54. 		}
    55.  
    56. 		if (key->_val > parent->_val)
    57. 		{
    58. 			parent->_right = key;
    59. 		}
    60. 		else
    61. 		{
    62. 			parent->_left = key;
    63. 		}
    64. 		return 1;
    65. 	}
    66. };

     （2.）递归版本

    这里面整了个活，大家注意了!!!

    1. bool Re_Insert(const T& val){  return Re_Insert_table(root, val);}
    2.  
    3. 	bool Re_Insert_table(BST_node*& node, const T& val)
    4. 	{
    5. 		if (node == nullptr)
    6. 		{
    7. 			node = new BST_node(val);
    8. 			return 1;
    9. 		}
    10.  
    11. 		if (val < node->_left)
    12. 		{
    13. 			return Re_Insert_table(node->_left, val);
    14. 		}
    15. 		else if (val > node->_right)
    16. 		{ 
    17. 			return Re_Insert_table(node->_right, val);
    18. 		}
    19. 		else
    20. 		{
    21. 			return 0;
    22. 		}
    23. 	}

    这里方便大家理解，我给大家花一个递归展开图。

     2. 打印搜索二叉树

     

    插入的具体过程如下：
    a. 树为空，则直接新增节点，赋值给root指针
    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

    这里也是仅做代码分享： 

    1. void Print_table() { Re_Print(root); }
    2.  
    3. 	void Re_Print(const BST_node* node)
    4. 	{
    5. 		if (node == nullptr)
    6. 			return;
    7. 		Re_Print(node->_left);
    8. 		cout << node->_val << " ";
    9. 		Re_Print(node->_right);
    10. 	}

    3.查找函数

    思路：其实也没啥思路，比父结点小，就找左边，否则找右边。 

    （1.）非递归版本

    1. BST_node* Find(const T& val)
    2. 	{
    3. 		//直接跟寻找位置一样
    4. 		BST_node* parent = nullptr;
    5. 		BST_node* cur = root; // 以返回cur的方式返回
    6.  
    7. 		while (cur)   // 非递归版本
    8. 		{
    9. 			if (val < cur->_val)
    10. 			{
    11. 				parent = cur;
    12. 				cur = cur->_left;
    13. 			}
    14. 			else if (val > cur->_val)
    15. 			{
    16. 				parent = cur;
    17. 				cur = cur->_right;
    18. 			}
    19. 			else
    20. 			{
    21. 				return cur;
    22. 			}
    23. 		}
    24. 		return cur;
    25. 	}

    （2.）递归版本

    1. BST_node* Re_Find(const T& val){   return Re_Find_table(root, val); }
    2. 	
    3. 	BST_node* Re_Find_table(BST_node* node, const T& val)
    4. 	{
    5. 		if (node == nullptr)
    6. 			return nullptr;
    7.  
    8. 		if (val < node->_val)
    9. 		{
    10. 			return Re_Find_table(node->_left, val);
    11. 		}
    12. 		else if (val > node->_val)
    13. 		{
    14. 			return Re_Find_table(node->_right, val);
    15. 		}
    16. 		else
    17. 		{
    18. 			return node;
    19. 		}
    20. 	}

    4. 删除函数（重难点） 

    我们简单寻找了一下思路，如下：

    但这些思路只是大概方向，其中藏着许多的坑点，诺接下来我来带大家，对这些易错点进行分析。

    首先是查询到目标：

    这个比较简单，这里不做解释。 

    1.        //首先寻找到目标,并且记录到parent
    2. 		BST_node* parent = nullptr;
    3. 		BST_node* cur = root;
    4. 		while (cur)
    5. 		{
    6. 			if (val < cur->_val)
    7. 			{
    8. 				parent = cur;
    9. 				cur = cur->_left;
    10. 			}
    11. 			else if (val > cur->_val)
    12. 			{
    13. 				parent = cur;
    14. 				cur = cur->_right;
    15. 			}
    16. 			else
    17. 			{
    18. 				break;
    19. 			}
    20. 		}
    21. 		if (!cur)
    22. 		{
    23. 			return 0;
    24. 		}

    易错点分析，包你学会

    （1.）删除目标，没有左右孩子

     

    （2.）删除目标，只有一个孩子

    一般的思路： 

     但，这是有漏洞的！

    诺：

    （3.）删除目标，有两个孩子

     好啦，前菜上完了来看看，本次的大菜。

    代码

    （1.）非递归版本 

    1. bool Erase(const T& val)
    2. 	{
    3. 		//首先寻找到指定值,并且记录到parent
    4. 		BST_node* parent = nullptr;
    5. 		BST_node* cur = root;
    6. 		while (cur)
    7. 		{
    8. 			if (val < cur->_val)
    9. 			{
    10. 				parent = cur;
    11. 				cur = cur->_left;
    12. 			}
    13. 			else if (val > cur->_val)
    14. 			{
    15. 				parent = cur;
    16. 				cur = cur->_right;
    17. 			}
    18. 			else
    19. 			{
    20. 				break;
    21. 			}
    22. 		}
    23. 		if (!cur)
    24. 		{
    25. 			return 0;
    26. 		}
    27.  
    28. 		// 查询成功,开始删除
    29. 		if (!cur->_left && !cur->_right) // cur没有左右孩子
    30. 		{   // 当要删除目标是根
    31. 			if (cur == root)
    32. 			{
    33. 				root = nullptr;
    34. 				delete cur;
    35. 			}
    36. 			// 判断cur是左右孩子
    37. 			else if (cur->_val < parent->_val)
    38. 			{
    39. 				parent->_left = nullptr;
    40. 				delete cur;
    41. 			}
    42. 			else
    43. 			{
    44. 				parent->_right = nullptr;
    45. 				delete cur;
    46. 			}
    47. 			return 1;
    48. 		}
    49. 		else if (!cur->_left || !cur->_right)  // 只有一个孩子
    50. 		{
    51. 			if (!parent)  // 判断是否是目标是根
    52. 			{
    53. 				root = cur->_left != nullptr ? cur->_left : cur->_right;
    54. 				delete cur;
    55. 			}
    56. 			// 判断cur为啥孩子
    57. 			else if (cur->_val < parent->_val) // 左侧
    58. 			{
    59. 				parent->_left = cur->_left != nullptr ? cur->_left : cur->_right;
    60. 				delete cur;
    61. 			}
    62. 			else                          // 右侧
    63. 			{
    64. 				parent->_right = cur->_left != nullptr ? cur->_left : cur->_right;
    65. 				delete cur;
    66. 			}
    67. 		}
    68. 		else   // 有2个孩子
    69. 		{  // 使用左侧最大的孩子来领养
    70. 			// 寻找左侧最大
    71. 			BST_node* maxnode = cur->_left;
    72. 			BST_node* max_parent = cur;
    73. 			while (maxnode->_right)
    74. 			{
    75. 				max_parent = maxnode;
    76. 				maxnode = maxnode->_right;
    77. 			}
    78. 			
    79. 			// 现在又进入一种特殊情况,1.max_parent就没进入循环，2.进入了循环
    80. 			if (max_parent == cur)
    81. 			{
    82. 				max_parent->_left = maxnode->_left;
    83. 			}
    84. 			else
    85. 			{
    86. 				max_parent->_right = maxnode->_left;
    87. 			}
    88. 			// 值转移
    89. 			cur->_val = maxnode->_val;
    90. 			delete maxnode;
    91. 		}
    92. 		return 1;
    93. 	}

    （2.）递归版本

    1. bool Re_Erease( const T& val)
    2. 	{
    3. 		return Re_Erease_table(root, val);
    4. 	}
    5.  
    6. 	bool Re_Erease_table(BST_node*& node, const T& val)
    7. 	{
    8. 		// 首先我们先找到值
    9. 		if (node == nullptr)
    10. 		{
    11. 			return 0; // 如果访问到了空，则说明删除失败，原因是：不存在
    12. 		}
    13.  
    14. 		if (val < node->_val)
    15. 		{
    16. 			return Re_Erease_table(node->_left, val);
    17. 		}
    18. 		else if (val > node->_val)
    19. 		{
    20. 			return Re_Erease_table(node->_right, val);
    21. 		}
    22. 		else
    23. 		{
    24. 			// 开始删除目标数据。方法如下；
    25. 			// 1. 就按照非递归的思路，不用改多少代码 
    26. 			// 2. 使用递归方法，优势就是代码简洁
    27. 			// 这里使用方法2
    28. 			BST_node* del = node;  // 保存每次访问的对象，如果是目标，就备份好了
    29. 			if (node->_left == nullptr)
    30. 			{
    31. 				node = node->_right;
    32. 			}
    33. 			else if (node->_right == nullptr)
    34. 			{
    35. 				node = node->_left;
    36. 			}
    37. 			else
    38. 			{
    39. 				//处理左右都有孩子的目标
    40. 				// 左侧查找最大值，右侧查找最小值
    41. 				BST_node* max_node = node->_left;
    42. 				while (max_node->_right)
    43. 				{
    44. 					max_node = max_node->_right;
    45. 				}
    46. 				// 完成循环后，max_node最多有左孩子，然后数据交换，我们以目标左侧树为起点
    47. 				// 再次递归删除替换数据。
    48. 				swap(max_node->_val, node->_val);
    49. 				return Re_Erease_table(node->_left, val); //已经完成删除，就直接退出，以免触发删除delete
    50. 			}			
    51. 			//处理前两种情况
    52. 			delete del;
    53. 		}
    54. 	}

    5. 析构函数

    思路：

    1. ~BSTree()
    2. 	{  
    3. 		Distroy_Re(root);
    4. 		root = nullptr;   
    5. 	}
    6. void Distroy_Re(BST_node*& node) // 我们采用递归删除
    7. 	{
    8. 		if (node == nullptr)
    9. 			return ;
    10. 		// 先处理左右孩子
    11. 		Distroy_Re(node->_left);
    12. 		Distroy_Re(node->_right);
    13. 		delete node;
    14. 		node = nullptr;
    15. 	}

    6.拷贝构造 

    1.     // 我们实现了拷贝构造，默认构造函数则不会生成 
    2. 	// 解决方案：1.实现构造函数 2.使用default关键字，强制生成默认构造
    3. 	BSTree()                 
    4. 	{
    5. 	}
    6. 	 // BSTree() = default
    7.  
    8.      BSTree(const BSTree& Tree) // 拷贝构造
    9. 	{
    10. 		root = copy(Tree.root);
    11. 	}
    12.  
    13. 	BST_node* copy(BST_node* root)
    14. 	{
    15. 		if (root == nullptr)
    16. 			return nullptr;
    17.  
    18. 		BST_node* new_node = new BST_node(root->_val);
    19. 		new_node->_left = copy(root->_left);
    20. 		new_node->_right = copy(root->_right);
    21. 		return new_node;
    22. 	}

     三，应用

    1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
    的值。
         比如： 给一个单词word，判断该单词是否拼写正确，具体方式如下：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
    2. KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：
         比如 英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；
    再比如 统计单词次数，统计成功后，给定单词就可快速找到其出现的次数， 单词与其出现次数就是就构成一种键值对（这个比较简单，修改一下即可）

     四，搜索二叉树的缺陷及优化

    对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
    但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

    最坏情况：N

    平均情况：O(logN)

    问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上场了。

    五，代码汇总

    1. namespace key
    2. {
    3. template <class K>
    4. class BinarySeaTree_node
    5. {
    6. 	typedef BinarySeaTree_node BST_node;
    7. public:
    8. 	BinarySeaTree_node(const K& val)
    9. 		: _val(val)
    10. 		,_left(nullptr)
    11. 		,_right(nullptr)
    12. 	{}
    13.  
    14. 	K _val;
    15. 	BST_node* _left;
    16. 	BST_node* _right;
    17. };
    18.  
    19. template <class T>
    20. class BSTree
    21. {
    22. public:
    23. 	typedef BinarySeaTree_node BST_node;
    24.  
    25. 	// 我们实现了拷贝构造，默认构造函数则不会生成 
    26. 	// 解决方案：1.实现构造函数 2.使用default关键字，强制生成默认构造
    27. 	BSTree()
    28. 	{
    29. 	}
    30.  
    31. 	// BSTree() = default
    32.    BSTree(const BSTree& Tree) // 拷贝构造
    33.    {
    34. 	   root = copy(Tree.root);
    35.    }
    36.  
    37.    BSTree& operator=(BSTree t)
    38.    {
    39. 	   swap(root, t.root);
    40. 	   return *this;
    41.    }
    42.  
    43.    BST_node* copy(BST_node* root)
    44.    {
    45. 	   if (root == nullptr)
    46. 		   return nullptr;
    47.  
    48. 	   BST_node* new_node = new BST_node(root->_val);
    49. 	   new_node->_left = copy(root->_left);
    50. 	   new_node->_right = copy(root->_right);
    51. 	   return new_node;
    52.    }
    53.  
    54.    bool Re_Insert(const T& val) { return Re_Insert_table(root, val); }
    55.    void Re_Print() { Re_Print_table(root); }
    56.    bool Re_Erease(const T& val) { return Re_Erease_table(root, val); }
    57.    BST_node* Re_Find(const T& val) { return Re_Find_table(root, val); }
    58.  
    59.    bool Insert(const T& val)
    60.    {
    61. 	   BST_node* key = new BST_node(val);
    62. 	   BST_node* cur = root;
    63. 	   BST_node* parent = nullptr;
    64. 	   while (cur)
    65. 	   {
    66. 		   if (key->_val < cur->_val)
    67. 		   {
    68. 			   parent = cur;
    69. 			   cur = cur->_left;
    70. 		   }
    71. 		   else if (key->_val > cur->_val)
    72. 		   {
    73. 			   parent = cur;
    74. 			   cur = cur->_right;
    75. 		   }
    76. 		   else
    77. 		   {
    78. 			   return 0;
    79. 		   }
    80. 	   }
    81.  
    82. 	   // 查询好位置后，建立链接
    83. 	   if (!root)
    84. 	   {
    85. 		   root = key;
    86. 		   return 0;
    87. 	   }
    88.  
    89. 	   if (key->_val > parent->_val)
    90. 	   {
    91. 		   parent->_right = key;
    92. 	   }
    93. 	   else
    94. 	   {
    95. 		   parent->_left = key;
    96. 	   }
    97. 	   return 1;
    98.    }
    99.  
    100.    BST_node* Find(const T& val)
    101.    {
    102. 	   //直接跟寻找位置一样
    103. 	   BST_node* parent = nullptr;
    104. 	   BST_node* cur = root; // 以返回cur的方式返回
    105.  
    106. 	   while (cur)   // 非递归版本
    107. 	   {
    108. 		   if (val < cur->_val)
    109. 		   {
    110. 			   parent = cur;
    111. 			   cur = cur->_left;
    112. 		   }
    113. 		   else if (val > cur->_val)
    114. 		   {
    115. 			   parent = cur;
    116. 			   cur = cur->_right;
    117. 		   }
    118. 		   else
    119. 		   {
    120. 			   return cur;
    121. 		   }
    122. 	   }
    123. 	   return cur;
    124.    }
    125.  
    126.    bool Erase(const T& val)
    127.    {
    128. 	   //首先寻找到指定值,并且记录到parent
    129. 	   BST_node* parent = nullptr;
    130. 	   BST_node* cur = root;
    131. 	   while (cur)
    132. 	   {
    133. 		   if (val < cur->_val)
    134. 		   {
    135. 			   parent = cur;
    136. 			   cur = cur->_left;
    137. 		   }
    138. 		   else if (val > cur->_val)
    139. 		   {
    140. 			   parent = cur;
    141. 			   cur = cur->_right;
    142. 		   }
    143. 		   else
    144. 		   {
    145. 			   break;
    146. 		   }
    147. 	   }
    148. 	   if (!cur)
    149. 	   {
    150. 		   return 0;
    151. 	   }
    152.  
    153. 	   // 查询成功,开始删除
    154. 	   if (!cur->_left && !cur->_right) // cur没有左右孩子
    155. 	   {   // 当要删除目标是根
    156. 		   if (cur == root)
    157. 		   {
    158. 			   root = nullptr;
    159. 			   delete cur;
    160. 		   }
    161. 		   // 判断cur是左右孩子
    162. 		   else if (cur->_val < parent->_val)
    163. 		   {
    164. 			   parent->_left = nullptr;
    165. 			   delete cur;
    166. 		   }
    167. 		   else
    168. 		   {
    169. 			   parent->_right = nullptr;
    170. 			   delete cur;
    171. 		   }
    172. 		   return 1;
    173. 	   }
    174. 	   else if (!cur->_left || !cur->_right)  // 只有一个孩子
    175. 	   {
    176. 		   if (!parent)  // 判断是否是目标是根
    177. 		   {
    178. 			   root = cur->_left != nullptr ? cur->_left : cur->_right;
    179. 			   delete cur;
    180. 		   }
    181. 		   // 判断cur为啥孩子
    182. 		   else if (cur->_val < parent->_val) // 左侧
    183. 		   {
    184. 			   parent->_left = cur->_left != nullptr ? cur->_left : cur->_right;
    185. 			   delete cur;
    186. 		   }
    187. 		   else                          // 右侧
    188. 		   {
    189. 			   parent->_right = cur->_left != nullptr ? cur->_left : cur->_right;
    190. 			   delete cur;
    191. 		   }
    192. 	   }
    193. 	   else   // 有2个孩子
    194. 	   {  // 使用左侧最大的孩子来领养
    195. 		   // 寻找左侧最大
    196. 		   BST_node* maxnode = cur->_left;
    197. 		   BST_node* max_parent = cur;
    198. 		   while (maxnode->_right)
    199. 		   {
    200. 			   max_parent = maxnode;
    201. 			   maxnode = maxnode->_right;
    202. 		   }
    203.  
    204. 		   // 现在又进入一种特殊情况,1.max_parent就没进入循环，2.进入了循环
    205. 		   if (max_parent == cur)
    206. 		   {
    207. 			   max_parent->_left = maxnode->_left;
    208. 		   }
    209. 		   else
    210. 		   {
    211. 			   max_parent->_right = maxnode->_left;
    212. 		   }
    213. 		   // 值转移
    214. 		   cur->_val = maxnode->_val;
    215. 		   delete maxnode;
    216. 	   }
    217. 	   return 1;
    218.    }
    219.  
    220.    ~BSTree()
    221.    {
    222. 	   Distroy_Re(root);
    223. 	   root = nullptr;
    224.    }
    225.  
    226. protected:
    227. 	bool Re_Insert_table(BST_node*& node, const T& val)
    228. 	{
    229. 		if (node == nullptr)
    230. 		{
    231. 			node = new BST_node(val);
    232. 			return 1;
    233. 		}
    234.  
    235. 		if (val < node->_val)
    236. 		{
    237. 			return Re_Insert_table(node->_left, val);
    238. 		}
    239. 		else if (val > node->_val)
    240. 		{
    241. 			return Re_Insert_table(node->_right, val);
    242. 		}
    243. 		else
    244. 		{
    245. 			return 0;
    246. 		}
    247. 	}
    248.  
    249. 	void Re_Print_table(const BST_node* node)
    250. 	{
    251. 		if (node == nullptr)
    252. 			return;
    253. 		Re_Print_table(node->_left);
    254. 		cout << node->_val << " ";
    255. 		Re_Print_table(node->_right);
    256. 	}
    257.  
    258. 	BST_node* Re_Find_table(BST_node* node, const T& val)
    259. 	{
    260. 		if (node == nullptr)
    261. 			return nullptr;
    262.  
    263. 		if (val < node->_val)
    264. 		{
    265. 			return Re_Find_table(node->_left, val);
    266. 		}
    267. 		else if (val > node->_val)
    268. 		{
    269. 			return Re_Find_table(node->_right, val);
    270. 		}
    271. 		else
    272. 		{
    273. 			return node;
    274. 		}
    275. 	}
    276.  
    277. 	bool Re_Erease_table(BST_node*& node, const T& val)
    278. 	{
    279. 		// 首先我们先找到值
    280. 		if (node == nullptr)
    281. 		{
    282. 			return 0; // 如果访问到了空，则说明删除失败，原因是：不存在
    283. 		}
    284.  
    285. 		if (val < node->_val)
    286. 		{
    287. 			return Re_Erease_table(node->_left, val);
    288. 		}
    289. 		else if (val > node->_val)
    290. 		{
    291. 			return Re_Erease_table(node->_right, val);
    292. 		}
    293. 		else
    294. 		{
    295. 			// 开始删除目标数据。方法如下；
    296. 			// 1. 就按照非递归的思路，不用改多少代码 
    297. 			// 2. 使用递归方法，优势就是代码简洁
    298.  
    299. 			// 这里使用方法2
    300. 			BST_node* del = node;  // 保存每次访问的对象，如果是目标，就备份好了
    301. 			if (node->_left == nullptr)
    302. 			{
    303. 				node = node->_right;
    304. 			}
    305. 			else if (node->_right == nullptr)
    306. 			{
    307. 				node = node->_left;
    308. 			}
    309. 			else
    310. 			{
    311. 				//处理左右都有孩子的目标
    312. 				// 左侧查找最大值，右侧查找最小值
    313. 				BST_node* max_node = node->_left;
    314. 				while (max_node->_right)
    315. 				{
    316. 					max_node = max_node->_right;
    317. 				}
    318. 				// 完成循环后，max_node最多有左孩子，然后数据交换，我们以目标左侧树为起点
    319. 				// 再次递归删除替换数据。
    320. 				swap(max_node->_val, node->_val);
    321. 				return Re_Erease_table(node->_left, val); //已经完成删除，就直接退出，以免触发删除delete
    322. 			}
    323. 			// 查找到删除数据
    324. 			delete del;
    325. 		}
    326. 	}
    327.  
    328. 	void Distroy_Re(BST_node*& node) // 我们采用递归删除
    329. 	{
    330. 		if (node == nullptr)
    331. 			return;
    332. 		// 先处理左右孩子
    333. 		Distroy_Re(node->_left);
    334. 		Distroy_Re(node->_right);
    335. 		delete node;
    336. 		node = nullptr;
    337. 	}
    338. private:
    339. 	BST_node* root = nullptr;
    340.  };
    341. }

    结语

       本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力

  • 相关阅读:
    Presto (三) --------- Presto 优化
    【MAC】MacOS M2 芯片的Mysql 数据库安装与使用
    PCL 曲率 结构体
    C语言项目实战——贪吃蛇
    ElasticSearch是什么？有哪些应用？有哪些优缺点？
    机器学习（9）---线性回归中的公式推导(手推)、闭式解和数值解
    全球C++软件开发顾问约翰·拉科斯（John Lakos）新书即将上架
    PointNeXt：通过改进的模型训练和缩放策略审视PointNet++
    3D目标检测框架 MMDetection3D环境搭建 docker篇
    Appium 自动化测试环境搭建
  • 原文地址：https://blog.csdn.net/qq_72112924/article/details/132890262