• 搜索二叉树（二叉搜索树）的实现（递归与非递归）

    一、搜索二叉树的概念

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

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

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

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

    二、搜索二叉树的操作

    1. 搜索二叉树的查找

    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

    b、最多查找高度次，走到到空，还没找到，这个值不存在。

    1. template <class K>
    2. bool BSTree::Find(const K& key)
    3. {
    4. 	node* cur = _root;
    5. 	while (cur)
    6. 	{
    7. 		if (key < cur->_key)//小就往左走
    8. 		{
    9. 			cur = cur->_left;
    10. 		}
    11. 		else if (key > cur->_key)//大就往右走
    12. 		{
    13. 			cur = cur->_right;
    14. 		}
    15. 		else//找到了
    16. 		{
    17. 			return true;
    18. 		}
    19. 	}
    20. 	return false;
    21. }

    2. 搜索二叉树的插入

    a. 树为空，则直接新增节点，赋值给root指针

    b. 树不空，按搜索二叉树性质查找插入位置，插入新节点

    1. template <class K>
    2. bool BSTree::Insert(const K& key)
    3. {
    4. 	//树为空，则直接新增节点，赋值给root指针
    5. 	if (_root == nullptr)
    6. 	{
    7. 		_root = new node(key);
    8. 		return true;
    9. 	}
    10. 	node* parent = nullptr;
    11. 	node* cur = _root;
    12. 	while (cur)//找到key该去的位置
    13. 	{
    14. 		parent = cur;
    15. 		if (cur->_key < key)//大就往右走
    16. 		{
    17. 			cur = cur->_right;
    18. 		}
    19. 		else if (cur->_key > key)//小就往左走
    20. 		{
    21. 			cur = cur->_left;
    22. 		}
    23. 		else//有相等的值了无法再插入了
    24. 		{
    25. 			return false;
    26. 		}
    27. 	}
    28. 	if (parent->_key < key)
    29. 	{
    30. 		parent->_right = new node(key);
    31. 	}
    32. 	else
    33. 	{
    34. 		parent->_left = new node(key);
    35. 	}
    36.  
    37. 	return true;
    38. }

    3.搜索二叉树的删除

    删除的情况最为复杂，首先查找元素是否在搜索二叉树中，如果不存在，则返回, 否则要删除的结点分下面四种情况：

    a. 要删除的结点无孩子结点

    b. 要删除的结点只有左孩子结点

    c. 要删除的结点只有右孩子结点

    d. 要删除的结点有左、右孩子结点

    看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程 如下：

    情况a：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除

    情况b：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除

    情况c：在它的右子树中寻找中序下的第一个结点(关键码最小)，或者在它的左子树中寻找中序下的第一个结点(关键码最大)用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除。

    1. template <class K>
    2. bool BSTree::Erase(const K& key)
    3. {
    4. 	node* parent = nullptr;
    5. 	node* cur = _root;
    6. 	while (cur)
    7. 	{
    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. 		else//找到了就跳出循环
    20. 		{
    21. 			break;
    22. 		}
    23. 	}
    24. 	if (cur == nullptr)//cur走到空就意味着没找到
    25. 	{
    26. 		return false;
    27. 	}
    28. 	if (cur->_left == nullptr)//左为空 
    29. 	{
    30. 		if (cur == _root)
    31. 		{
    32. 			_root = cur->_right;
    33. 		}
    34. 		else if (cur == parent->_left)
    35. 		{
    36. 			parent->_left = cur->_right;
    37. 		}
    38. 		else if (cur == parent->_right)
    39. 		{
    40. 			parent->_right = cur->_right;
    41. 		}
    42. 		delete cur;
    43. 		return true;
    44. 	}
    45. 	else if (cur->_right == nullptr)//右为空
    46. 	{
    47. 		if (cur == _root)
    48. 		{
    49. 			_root = cur->_left;
    50. 		}
    51. 		else if (cur == parent->_left)
    52. 		{
    53. 			parent->_left = cur->_left;
    54. 		}
    55. 		else if (cur == parent->_right)
    56. 		{
    57. 			parent->_right = cur->_left;
    58. 		}
    59. 		delete cur;
    60. 		return true;
    61. 	}
    62. 	else//左右都不为空，去找它左树最大的节点替换它的值，再删除左树最大的节点
    63.         //下面的图有做说明
    64. 	{
    65. 		node* parent = nullptr;
    66. 		node* leftMax = cur;
    67. 		while (leftMax->_right)//找到左树最大的节点
    68. 		{
    69. 			parent = leftMax;
    70. 			leftMax = leftMax->_right;
    71. 		}
    72. 		swap(cur->_key, leftMax->_key);//交换值
    73. 		if (parent->_left == leftMax)
    74. 		{
    75. 			parent->_left = leftMax->_left;
    76. 		}
    77. 		else
    78. 		{
    79. 			parent->_right = leftMax->_left;
    80. 		}
    81. 		delete leftMax;
    82. 		return true;
    83. 	}
    84. 	return false;
    85. }

    三、搜索二叉树的完整代码实现

    1. #pragma once
    2.  
    3. #include 
    4. using namespace std;
    5.  
    6.  
    7. template <class K>
    8. struct BSTreeNode
    9. {
    10. 	BSTreeNode* _left;
    11. 	BSTreeNode* _right;
    12. 	K _key;
    13.  
    14. 	BSTreeNode(const K& key)
    15. 		:_left(nullptr)
    16. 		,_right(nullptr)
    17. 		,_key(key)
    18. 	{}
    19. };
    20.  
    21. template <class K>
    22. class BSTree
    23. {
    24. private:
    25. 	BSTreeNode* _root;
    26. 	typedef BSTreeNode node;
    27. public:
    28. 	BSTree()
    29. 		:_root(nullptr)
    30. 	{
    31.  
    32. 	}
    33. 	~BSTree()
    34. 	{
    35. 		Destroy(_root);
    36. 	}
    37. 	//增删查
    38. 	bool Insert(const K& key);
    39. 	bool Find(const K& key);
    40. 	bool Erase(const K& key);
    41. 	//中序遍历
    42. 	void InOrder();
    43. 	void _InOrder(node* root);
    44. 	//增删查的递归实现
    45. 	bool InsertR(const K& key);
    46. 	bool _InsertR(const K& key, node*& root);
    47. 	//为了对节点进行修改，这里的插入和删除的节点必须用引用传，这里是一个细节 
    48. 	bool EraseR(const K& key);
    49. 	bool _EraseR(const K& key, node*& root);
    50. 	bool FindR(const K& key);
    51. 	bool _FindR(const K& key, node* root);
    52.  
    53. 	void Destroy(node* root);
    54. };
    55.  
    56.  
    57. template <class K>
    58. bool BSTree::Insert(const K& key)
    59. {
    60. 	//树为空，则直接新增节点，赋值给root指针
    61. 	if (_root == nullptr)
    62. 	{
    63. 		_root = new node(key);
    64. 		return true;
    65. 	}
    66. 	node* parent = nullptr;
    67. 	node* cur = _root;
    68. 	while (cur)//找到key该去的位置
    69. 	{
    70. 		parent = cur;
    71. 		if (cur->_key < key)//大就往右走
    72. 		{
    73. 			cur = cur->_right;
    74. 		}
    75. 		else if (cur->_key > key)//小就往左走
    76. 		{
    77. 			cur = cur->_left;
    78. 		}
    79. 		else//有相等的值了无法再插入了
    80. 		{
    81. 			return false;
    82. 		}
    83. 	}
    84. 	if (parent->_key < key)
    85. 	{
    86. 		parent->_right = new node(key);
    87. 	}
    88. 	else
    89. 	{
    90. 		parent->_left = new node(key);
    91. 	}
    92.  
    93. 	return true;
    94. }
    95.  
    96. template <class K>
    97. bool BSTree::Find(const K& key)
    98. {
    99. 	node* cur = _root;
    100. 	while (cur)
    101. 	{
    102. 		if (key < cur->_key)//小就往左走
    103. 		{
    104. 			cur = cur->_left;
    105. 		}
    106. 		else if (key > cur->_key)//大就往右走
    107. 		{
    108. 			cur = cur->_right;
    109. 		}
    110. 		else//找到了
    111. 		{
    112. 			return true;
    113. 		}
    114. 	}
    115. 	return false;
    116. }
    117.  
    118. template <class K>
    119. bool BSTree::Erase(const K& key)
    120. {
    121. 	node* parent = nullptr;
    122. 	node* cur = _root;
    123. 	while (cur)
    124. 	{
    125. 		
    126. 		if (cur->_key > key)
    127. 		{
    128. 			parent = cur;
    129. 			cur = cur->_left;
    130. 		}
    131. 		else if (cur->_key < key)
    132. 		{
    133. 			parent = cur;
    134. 			cur = cur->_right;
    135. 		}
    136. 		else//找到了就跳出循环
    137. 		{
    138. 			break;
    139. 		}
    140. 	}
    141. 	if (cur == nullptr)//cur走到空就意味着没找到
    142. 	{
    143. 		return false;
    144. 	}
    145. 	if (cur->_left == nullptr)//左为空 
    146. 	{
    147. 		if (cur == _root)
    148. 		{
    149. 			_root = cur->_right;
    150. 		}
    151. 		else if (cur == parent->_left)
    152. 		{
    153. 			parent->_left = cur->_right;
    154. 		}
    155. 		else if (cur == parent->_right)
    156. 		{
    157. 			parent->_right = cur->_right;
    158. 		}
    159. 		delete cur;
    160. 		return true;
    161. 	}
    162. 	else if (cur->_right == nullptr)//右为空
    163. 	{
    164. 		if (cur == _root)
    165. 		{
    166. 			_root = cur->_left;
    167. 		}
    168. 		else if (cur == parent->_left)
    169. 		{
    170. 			parent->_left = cur->_left;
    171. 		}
    172. 		else if (cur == parent->_right)
    173. 		{
    174. 			parent->_right = cur->_left;
    175. 		}
    176. 		delete cur;
    177. 		return true;
    178. 	}
    179. 	else//左右都不为空，去找它左树最大的节点替换它的值，再删除左树最大的节点
    180. 	{
    181. 		node* parent = nullptr;
    182. 		node* leftMax = cur;
    183. 		while (leftMax->_right)//找到左树最大的节点
    184. 		{
    185. 			parent = leftMax;
    186. 			leftMax = leftMax->_right;
    187. 		}
    188. 		swap(cur->_key, leftMax->_key);//交换值
    189. 		if (parent->_left == leftMax)
    190. 		{
    191. 			parent->_left = leftMax->_left;
    192. 		}
    193. 		else
    194. 		{
    195. 			parent->_right = leftMax->_left;
    196. 		}
    197. 		delete leftMax;
    198. 		return true;
    199. 	}
    200. 	return false;
    201. }
    202.  
    203. template <class K>
    204. void BSTree::_InOrder(node* root)
    205. {
    206. 	if (root == nullptr)
    207. 		return;
    208. 	_InOrder(root->_left);
    209. 	cout << root->_key << " ";
    210. 	_InOrder(root->_right);
    211. }
    212.  
    213. template <class K>
    214. void BSTree::InOrder()
    215. {
    216. 	_InOrder(_root);
    217. 	cout << endl;
    218. }
    219.  
    220.  
    221. template <class K>
    222. bool BSTree::EraseR(const K& key)
    223. {
    224. 	return _EraseR(key, _root);
    225. }
    226.  
    227.  
    228. template <class K>
    229. bool BSTree::_EraseR(const K& key, node*& root)
    230. {
    231. 	if (root == nullptr)
    232. 		return false;
    233. 	if (root->_key < key)
    234. 	{
    235. 		_EraseR(key, root->_right);
    236. 	}
    237. 	else if (root->_key > key)
    238. 	{
    239. 		_EraseR(key, root->_left);
    240. 	}
    241. 	else//找到要删除的节点了
    242. 	{
    243. 		//准备开始删除
    244. 		node* del = root;
    245. 		if (root->_left == nullptr)
    246. 		{
    247. 			root = root->_right;
    248. 		}
    249. 		else if (root->_right == nullptr)
    250. 		{
    251. 			root = root->_left;
    252. 		}
    253. 		else
    254. 		{
    255. 			node* leftMax = root->_left;
    256. 			while (leftMax->_right)
    257. 			{
    258. 				leftMax = leftMax->_right;
    259. 			}
    260. 			swap(root->_key, leftMax->_key);
    261. 			return _EraseR(key, root->_left);//交换完后去要删除节点的左子树删除最大的节点
    262. 		}
    263. 		delete del;
    264. 	}
    265. 	return true;
    266. }
    267.  
    268. template <class K>
    269. bool BSTree::FindR(const K& key)
    270. {
    271. 	return _FindR(key, _root);
    272. }
    273.  
    274. template <class K>
    275. bool BSTree::_FindR(const K& key, node* root)
    276. {
    277. 	if (root == nullptr)
    278. 	{
    279. 		return false;
    280. 	}
    281. 	if (root->_key < key)
    282. 	{
    283. 		return _FindR(key, root->_right);
    284. 	}
    285. 	else if (root->_key > key)
    286. 	{
    287. 		return _FindR(key, root->_left);
    288. 	}
    289. 	else
    290. 	{
    291. 		return true;
    292. 	}
    293. }
    294.  
    295. template <class K>
    296. bool BSTree::InsertR(const K& key)
    297. {
    298. 	return _InsertR(key, _root);
    299. }
    300. template <class K>
    301. bool BSTree::_InsertR(const K& key, node*& root)
    302. {
    303. 	if (root == nullptr)
    304. 	{
    305. 		root = new node(key);
    306. 		return true;
    307. 	}
    308. 	if (root->_key < key)
    309. 	{
    310. 		return _InsertR(key, root->_right);
    311. 	}
    312. 	else if (root->_key > key)
    313. 	{
    314. 		return _InsertR(key, root->_left);
    315. 	}
    316. 	else
    317. 	{
    318. 		return false;
    319. 	}
    320. }
    321.  
    322. template <class K>
    323. void BSTree::Destroy(node* root)
    324. {
    325. 	if (root == nullptr)
    326. 		return;
    327. 	Destroy(root->_left);
    328. 	Destroy(root->_right);
    329. 	delete root;
    330. }
    1. //test.c
    2.  
    3. #include "BinarySearchTree.h"
    4.  
    5. int main()
    6. {
    7. 	BSTree<int> bs;
    8.  
    9. 	int arr[] = { 1,3,6,4,7,8,10,14,13 };
    10. 	for (auto e : arr)
    11. 	{
    12. 		bs.Insert(e);
    13. 	}
    14. 	bs.InOrder();
    15.  
    16. 	bs.EraseR(1);
    17. 	bs.InOrder();
    18.  
    19. 	bs.Insert(20);
    20. 	bs.InsertR(9);
    21. 	bs.InOrder();
    22.  
    23. 	bool ret = bs.FindR(20);
    24. 	cout << ret << endl;
    25.  
    26.  
    27. 	return 0;
    28. }

  • 相关阅读:
    [暑假-边做边学版]Vue实战(2)
    spring的事务传播机制
    MySql
    Spring5之IOC容器中IOC操作之Bean管理(四)之FactoryBean、bean作用域以及bean生命周期
    【2022黑马程序员】Mysql索引总结
    基于STM32+腾讯云IO+微信小程序设计的混凝土智能养护系统
    map和set详解
    【Java第24期】：IO、存储、硬盘和文件系统的相关知识
    React useImperativeHandle Hook
    【OpenCV学习】第5课:图像模糊（均值滤波，高斯滤波）
  • 原文地址：https://blog.csdn.net/m0_74265792/article/details/134477690