• C++——二叉搜索树

    前言：这篇文章我们将分享一种新的数据结构类型——二叉搜索树。

    目录

    一、什么是二叉搜索树

    二、定义

    三、操作

    1.插入

     2.遍历 

    3.寻找

    4.删除

    四.完整代码

     总结

    一、什么是二叉搜索树

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

    • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
    • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
    • 它的左右子树也分别为二叉搜索树

    下面我们就来看看二叉搜索树的结构，及其提供的各种操作。 

    之所以能被称为二叉排序树，是因为其中序遍历的结果是树中所有节点值的升序序列。 

    二、定义

    1. template<class K>
    2. struct BSTreeNode
    3. {
    4. 	K _val;
    5. 	struct BSTreeNode* _left;
    6. 	struct BSTreeNode* _right;
    7.  
    8. 	BSTreeNode(const K& key)
    9. 		:_left(nullptr)
    10. 		,_right(nullptr)
    11. 		,_key(key)
    12. 	{}
    13. };
    14.  
    15. template<class K>
    16. class BSTree
    17. {
    18. 	typedef BSTreeNode Node;
    19. public:
    20.  
    21. private:
    22. 	Node* _root = nullptr;
    23. };

    整体的定义结构与C语言定义的二叉树一致，只是这里使用的是C++类定义。 

    三、操作

    1.插入

    插入，我们首先要考虑的就是空树的判断。

    其次要注意，由于二叉搜索树是一个有顺序的树，所以我们就需要按照二叉搜索树的规则与每个节点的值进行比较不断往下走至叶子结点，最后成为新的叶子结点：

    1. 	bool Insert(const K& val)
    2. 	{
    3. 		if (_root == nullptr)
    4. 		{
    5. 			_root = new Node(val);
    6. 			return true;
    7. 		}
    8. 		Node* parent = nullptr;
    9. 		Node* cur = _root;
    10. 		while (cur)
    11. 		{
    12. 			if (cur->_val < val)
    13. 			{
    14. 				parent = cur;
    15. 				cur = cur->_right;
    16. 			}
    17. 			else if (cur->_val > val)
    18. 			{
    19. 				parent = cur;
    20. 				cur = cur->_left;
    21. 			}
    22. 			else
    23. 			{
    24. 				return false;
    25. 			}
    26. 		}
    27. 		cur = new Node(val);
    28. 		if (val < parent->_val)
    29. 		{
    30. 			parent->_left = cur;
    31. 		}
    32. 		else
    33. 		{
    34. 			parent->_right = cur;
    35. 		}
    36. 		return true;
    37. 	}

    在定义cur遍历比较的同时，我们还需要定义一个parent来记录最后新节点要插入的父节点。 

    由于二叉搜索树要起到搜索的作用，所以不允许存在元素相同的节点，所以我们要规避插入已有元素的情况。 

     2.遍历 

    遍历二叉树搜索树，直接采用中序遍历的方法：

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

    这里有一个小问题，如果该函数定义在public下，由于要传参数root，而root又是private私有成员，所以我们无法在类外调用私有成员进行参数的传递，所以优化一下：

    1. 	void InOrder()
    2. 	{
    3. 		inOrder(_root);
    4. 	}
    5. 	void inOrder(const Node* root)
    6. 	{
    7. 		if (root == nullptr)
    8. 		{
    9. 			return;
    10. 		}
    11. 		inOrder(root->_left);
    12. 		cout << root->_val << " ";
    13. 		inOrder(root->_right);
    14. 	}

    重新定义一个public成员函数InOrder，并将用该函数作为桥梁去调用inOrder，就可以避免传参。

    测试如下：

    3.寻找

    寻找其实就和插入类似，按照大小比较去遍历寻找：

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

    4.删除

    删除这个操作，可以说是二叉搜索树底层最复杂的一个操作，下面我们就通过下图来进行分析：

    关于节点的删除，我们要分析四种情况： 

    1.如果说我们要删除1、4、7、13这样的叶节点，那就非常方便，只用找到它，再记录它的父节点，将它删除后，再让父节点原本指向它的指针指向nullptr即可。

    2.如果是10、14这样的只有一个子节点的节点，我们只需让它的父节点去指向它的子节点即可，唯一要注意的是你是父节点的哪边的子节点，就让你的子节点成为哪边的子节点。

    3.如果是3、6这样的用有两个字节点的节点，如果把它删除，无法让它的父节点同时指向两个子节点，所以就必须找到另一个节点来顶替它的位置，否则就破坏了二叉搜索树的规则。

    那么这个顶替的节点应该是谁呢，要知道，这个新节点必须要比左子节点大，比右子节点小，那么我们就只有两种选择，一个是左子树的最大节点，一个是右子树的最小节点。

    这两个节点选择哪一个都可以，这里我们以选择右子树的最小节点为例。

     下面我们来一步步分析（代码不全仅供参考）：

    首先我们仍然是要通过循环遍历去找到要删除的节点，找不到则返回false。

    1. 		Node* parent = nullptr;
    2. 		Node* cur = _root;
    3. 		while (cur)
    4. 		{
    5. 			if (cur->_val < val)
    6. 			{
    7. 				parent = cur;
    8. 				cur = cur->_right;
    9. 			}
    10. 			else if (cur->_val > val)
    11. 			{
    12. 				parent = cur;
    13. 				cur = cur->_left;
    14. 			}

    其中叶节点的删除是可以和单子节点的删除混合的，来看：

    1. //左为空，父节点指向我的右节点
    2. 				if (cur->_left == nullptr)
    3. 				{
    4. 					if (cur == _root)
    5. 					{
    6. 						_root = cur->_right;
    7. 					}
    8. 					else
    9. 					{
    10. 						if (parent->_left == cur)
    11. 						{
    12. 							parent->_left = cur->_right;
    13. 						}
    14. 						else
    15. 						{
    16. 							parent->_right = cur->_right;
    17. 						}
    18. 					}
    19. 					delete cur;
    20. 				}
    21. 				//右为空，父节点指向我的左节点
    22. 				else if(cur->_right == nullptr)
    23. 				{
    24. 					if (cur == _root)
    25. 					{
    26. 						_root = cur->_left;
    27. 					}
    28. 					else
    29. 					{
    30. 						if (parent->_left == cur)
    31. 						{
    32. 							parent->_left = cur->_left;
    33. 						}
    34. 						else
    35. 						{
    36. 							parent->_right = cur->_left;
    37. 						}
    38. 					}
    39. 					delete cur;

    因为叶节点的左右子节点都为空，所以会默认进入if条件进行删除。 

    这里也比较简单，让cur的父节点原本指向它的指针转而去指向它的子节点。

    值得注意的是如果要删除的是根节点， 那么就直接让根的单子节点成为新根即可。

    最后来看拥有双子节点的cur如何删除：

    1.                     //左右都不为空，替换法删除
    2. 					//寻找右子树的最左节点删除
    3. 					Node* rightMinParent = cur;
    4. 					Node* rightMin = cur->_right;
    5. 					while (rightMin->_left)
    6. 					{
    7. 						rightMinParent = rightMin;
    8. 						rightMin = rightMin->_left;
    9. 					}
    10. 					swap(cur->_val, rightMin->_val);
    11. 					if (rightMinParent->_left == rightMin)
    12. 					{
    13. 						rightMinParent->_left = rightMin->_right;
    14. 					}
    15. 					else
    16. 					{
    17. 						rightMinParent->_right = rightMin->_right;
    18. 					}
    19. 					delete rightMin;

    思路为：找到cur的右子树的最小节点，将两者的数值交换，再去删除该最小节点。 

    首先我们需要定义cur的右子树的最小节点，及其父节点，然后去循环遍历找到二者，交换之后，再按照删除叶节点的方式删除该最小节点即可。

    测试如下：

    删除后我们的顺序并没有变化，说明我们的代码完全正确。

    四.完整代码

    1. template<class K>
    2. struct BSTreeNode
    3. {
    4. 	K _val;
    5. 	struct BSTreeNode* _left;
    6. 	struct BSTreeNode* _right;
    7.  
    8. 	BSTreeNode(const K& val)
    9. 		:_left(nullptr)
    10. 		,_right(nullptr)
    11. 		,_val(val)
    12. 	{}
    13. };
    14.  
    15. template<class K>
    16. class BSTree
    17. {
    18. 	typedef BSTreeNode Node;
    19. public:
    20. 	//插入
    21. 	bool Insert(const K& val)
    22. 	{
    23. 		if (_root == nullptr)
    24. 		{
    25. 			_root = new Node(val);
    26. 			return true;
    27. 		}
    28. 		Node* parent = nullptr;
    29. 		Node* cur = _root;
    30. 		while (cur)
    31. 		{
    32. 			if (cur->_val < val)
    33. 			{
    34. 				parent = cur;
    35. 				cur = cur->_right;
    36. 			}
    37. 			else if (cur->_val > val)
    38. 			{
    39. 				parent = cur;
    40. 				cur = cur->_left;
    41. 			}
    42. 			else
    43. 			{
    44. 				return false;
    45. 			}
    46. 		}
    47. 		cur = new Node(val);
    48. 		if (val < parent->_val)
    49. 		{
    50. 			parent->_left = cur;
    51. 		}
    52. 		else
    53. 		{
    54. 			parent->_right = cur;
    55. 		}
    56. 		return true;
    57. 	}
    58. 	//寻找
    59. 	bool Find(const K& val)
    60. 	{
    61. 		if (_root == nullptr)
    62. 		{
    63. 			return false;
    64. 		}
    65. 		Node* cur = _root;
    66. 		while (cur)
    67. 		{
    68. 			if (cur->_val < val)
    69. 			{
    70. 				cur = cur->_right;
    71. 			}
    72. 			else if (cur->_val > val)
    73. 			{
    74. 				cur = cur->_left;
    75. 			}
    76. 			else
    77. 			{
    78. 				return true;
    79. 			}
    80. 		}
    81. 		return false;
    82. 	}
    83. 	//删除
    84. 	bool erase(const K& val)
    85. 	{
    86. 		Node* parent = nullptr;
    87. 		Node* cur = _root;
    88. 		while (cur)
    89. 		{
    90. 			if (cur->_val < val)
    91. 			{
    92. 				parent = cur;
    93. 				cur = cur->_right;
    94. 			}
    95. 			else if (cur->_val > val)
    96. 			{
    97. 				parent = cur;
    98. 				cur = cur->_left;
    99. 			}
    100. 			else
    101. 			{
    102. 				//左为空，父节点指向我的右节点
    103. 				if (cur->_left == nullptr)
    104. 				{
    105. 					if (cur == _root)
    106. 					{
    107. 						_root = cur->_right;
    108. 					}
    109. 					else
    110. 					{
    111. 						if (parent->_left == cur)
    112. 						{
    113. 							parent->_left = cur->_right;
    114. 						}
    115. 						else
    116. 						{
    117. 							parent->_right = cur->_right;
    118. 						}
    119. 					}
    120. 					delete cur;
    121. 				}
    122. 				//右为空，父节点指向我的左节点
    123. 				else if(cur->_right == nullptr)
    124. 				{
    125. 					if (cur == _root)
    126. 					{
    127. 						_root = cur->_left;
    128. 					}
    129. 					else
    130. 					{
    131. 						if (parent->_left == cur)
    132. 						{
    133. 							parent->_left = cur->_left;
    134. 						}
    135. 						else
    136. 						{
    137. 							parent->_right = cur->_left;
    138. 						}
    139. 					}
    140. 					delete cur;
    141. 				}
    142. 				else
    143. 				{
    144. 					//左右都不为空，替换法删除
    145. 					//寻找右子树的最左节点删除
    146. 					Node* rightMinParent = cur;
    147. 					Node* rightMin = cur->_right;
    148. 					while (rightMin->_left)
    149. 					{
    150. 						rightMinParent = rightMin;
    151. 						rightMin = rightMin->_left;
    152. 					}
    153. 					swap(cur->_val, rightMin->_val);
    154. 					if (rightMinParent->_left == rightMin)
    155. 					{
    156. 						rightMinParent->_left = rightMin->_right;
    157. 					}
    158. 					else
    159. 					{
    160. 						rightMinParent->_right = rightMin->_right;
    161. 					}
    162. 					delete rightMin;
    163. 				}
    164.  
    165. 			}
    166. 		}
    167. 		return false;
    168. 	}
    169. 	//遍历
    170. 	void InOrder()
    171. 	{
    172. 		inOrder(_root);
    173. 		cout << endl;
    174. 	}
    175. 	void inOrder(const Node* root)
    176. 	{
    177. 		if (root == nullptr)
    178. 		{
    179. 			return;
    180. 		}
    181. 		inOrder(root->_left);
    182. 		cout << root->_val << " ";
    183. 		inOrder(root->_right);
    184. 	}
    185. private:
    186.  
    187. 	Node* _root = nullptr;
    188. };

     总结

    关于二叉搜索树的简单知识就分享到这里，喜欢本篇文章记得一键三连，我们下期再见。

  • 相关阅读:
    为什么 vm._data.date1 vm.date1 都可以访问，并且访问 同一个变量
    SOLIDWORKS® 2024 新功能 - 3D CAD
    卫星/RedCap/高算力/解决方案/创新金奖……移远通信为IOTE 2023再添新活力
    Nacos注册中心与配置管理
    231022|redis_demo
    选择合适的项目管理系统来支持专业产品研发团队
    sql执行计划需要关注那些内容？
    82 # koa-bodyparser 中间件的使用以及实现
    Python项目实战：制作一个翻译软件
    three.js学习笔记
  • 原文地址：https://blog.csdn.net/2303_78442132/article/details/138135807