• 模拟实现二叉搜索树（非kv模式）（上）

    本篇博客主要是讲解什么是二叉搜索树，以及模拟实现二叉搜索树的插入节点，中序遍历，查找特定节点，以及删除节点。

    什么是二叉搜索树

    首先二叉搜索树肯定是一棵二叉树，对于二叉树我们应该是陌生了。而我们在学习二叉树的时候知道，如果只是一棵普通的二叉树，用来储存数据是没有任何意义的，因为如果我们将数据放到一个普通的二叉树上，那么当我们需要查找这个值的时候我们只能将整棵树都遍历一遍，我们才能找到这个这个节点在二叉树中的位置。这和我们普通的使用数组没有什么区别。

    二叉搜索树则不同

    我们下面来看二叉搜素树的特点：

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

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

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

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

    下面是一张标准的搜索二叉树的图：这里还存在一个二叉搜索树的要求那就是在二叉搜索树的内部一般都是不存在重复值的。

    如果我这里想要寻找的值是7。那么我们不必和普通的二叉树一样，将整棵二叉树都遍历一遍，然后才能找到7的位置。

    而这里则不是首先7小于8所以我们去到了8的左子树，然后7大于3我们去到了3的右子树，最后6小于7我们去到6的右子树自然就找到了节点7。

    二叉搜索树的插入（非递归）

    在写二叉搜索树的插入之前我们先将二叉搜索树的结构和二叉搜索树节点的结构确定。

    二叉搜索树节点的结构：

    1. template<class T>
    2. struct BSNode
    3. {
    4. 	BSNode* _left;
    5. 	BSNode* _right;
    6. 	T _val;
    7. 	BSNode(const T& a)
    8. 		:_val(a)
    9. 		,_left(nullptr)
    10. 		,_right(nullptr)
    11. 	{}
    12. };

    二叉搜索树的结构

    1. template<class K>
    2. class BStree
    3. {
    4. 	typedef BSNode<K> Node;
    5. public:
    6.  
    7. private:
    8.   Node* _root;
    9. };

    确定好了结构之后我们来插入节点。

    首先如果我们要插入的这颗二叉搜索树一个节点都没有那么这个时候就很好插入。直接创建一个新的搜索树的节点，然后让_root 等于这个新创建出来空间的地址即可。

    其次如果存在值呢？

    如果存在值那么我们自然要使用一个cur指针，去寻找我们要插入的这个值在什么位置。找到了之后，将其链接到二叉树上即可。

    下面是代码的实现

    1. //首先来完成二叉搜索树的插入功能
    2. 	bool Insert(const K& val)
    3. 	{
    4. 		if (_root == nullptr)
    5. 		{
    6. 			_root = new Node(val);
    7. 			return true;
    8. 		}//这是一棵空树，所以这里直接让根节点成为一个节点即可。
    9. 		//运行到这里代表这一棵树不是空树，我们需要找到这个val应该插入在什么地方
    10. 		Node* cur = _root;
    11. 		Node* parent = nullptr;//确保最后能够链接
    12. 		while (cur)
    13. 		{
    14. 			parent = cur;//这个父节点是用于下面链接的
    15. 			if (cur->_val < val)
    16. 			{
    17. 				cur = cur->_right;
    18. 			}
    19. 			else if (cur->_val > val)
    20. 			{
    21. 				cur = cur->_left;
    22. 			}
    23. 			else//默认情况下二叉搜索树是不允许出现重复值的
    24. 			{
    25. 				return false;
    26. 			}
    27. 		}
    28. 		if (val < parent->_val)//当运行到这里的时候，我们的cur已经移动到了val应该在的位置，
    29.     //此时parennt正是我的val需要的父节点
    30. 			//现在只需要判断val是大于parent的_val还是小于parent的_val
    31. 		{
    32. 			parent->_left = new Node(val);
    33. 			return true;
    34. 		}
    35. 		else
    36. 		{
    37. 			parent->_right = new Node(val);
    38. 			return true;
    39. 		}
    40. 	}

    由此就能够完成插入节点的操作。

    中序遍历

    但是我们只是完成了一个插入操作，如果不使用监视窗口调试查看的话，我们是无法看到值是否真的储存正确了，所以这里我们需要完成一个中序遍历。对于二叉树的中序遍历我们只需要记住顺序是左子树，根，右子树，然后加上递归结束的判断条件。即可完成，但是和c语言的二叉树遍历不同我们这里出现了一个问题那就是我们在类外调用的时候，是无法拿到根节点的。那么这里存在两种解决方法，第一种方法，写一个Get_Root函数，将类中的_root节点返回给类外使用。

    第二个方法如下：

    1. void Inorder()
    2. 	{
    3. 		inorder(_root);//这里使用这种方法解决因为如果还是使用c语言的那种方法，
    4.     //会发现如果是在类外的话，我们无法
    5. 		//得到根节点，所以这里我们在创建一个函数来递归调用中序查看的方法
    6. 	}
    7.     //下面的函数我是放在private修饰的作用域中的所以在类外是无法使用下面的这个函数的
    8.     void inorder(Node* _root)
    9. 	{
    10. 		if (_root == nullptr)
    11. 		{
    12. 			return;
    13. 		}
    14. 		inorder(_root->_left);
    15. 		cout << _root->_val << " ";
    16. 		inorder(_root->_right);
    17. 	}

    现在有了插入和中序遍历的函数，我们就来看一下我们的这棵二叉搜索树是否是正确的。

    1. int main()
    2. {
    3. 	BStree<int> tree;
    4. 	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    5. 	for (auto e : a)
    6. 	{
    7. 		tree.InsertR(e);
    8. 	}
    9. 	tree.Inorder();
    10. 	return 0;
    11. }

    没有出现错误，中序遍历的结果也是正确的，我这里构建的正是下图中的这棵二叉搜索树：

    中序遍历的结果也是正确的，这里我们也能看出来为什么，二叉搜索树还有一个名字是排序二叉树，而map能够拥有排序的功能也正是因为底层使用了二叉搜索树。

    查找函数（非递归）

    对于查找函数就很简单了，只需要记住二叉搜素树的特点就可了。

    1. bool Find(const K& val)
    2. 	{
    3. 		Node* cur = _root;
    4. 		while (cur)
    5. 		{
    6. 			if (cur->_val < val)
    7. 			{
    8. 				cur = cur->_right;
    9. 			}
    10. 			else if (cur->_val > val)
    11. 			{
    12. 				cur = cur->_left;
    13. 			}
    14. 			else
    15. 			{
    16. 				return true;//代表找到了这个节点
    17. 			}
    18. 		}
    19. 		return false;//没有找到这个节点
    20. 	}

    下面我们依旧是检测一下这个函数是否可用。

    发现没有问题。

    搜索树的删除（非递归）

    那么下面我们就来实现第一个比较难的函数，删除节点的函数。

    我们首先拿上图分析一下我们删除各个节点可能遇到的问题：

    第1个要删除的节点具有一个左子节点

    这里我们假设1要删除的节点是14，那么我们要怎么做呢？这里存在一个方法就是"托孤",这里你可以理解成这里的14号节点要出去玩，但是这个14号节点是具有左孩子的。而自己又是父节点的右孩子所以这里就可以将14号节点的左子树成为10号节点的新右子树（因为14号节点就是10号的右子节点，如果14号是10号的左子节点，这里14的左子树就要成为10号的左子树），此时没有破坏二叉搜索树的结构，这样也能完成对14号节点的删除。这里需要注意的一个点就是如果我们要删除的这个节点刚好是根节点呢？

    如下图：

    此时的8是没有右子树的，所以为了再将8删除后不影响整颗树，就可以选择让8的左子节点成为新的_root,这样即使8被删除了依旧能够保持整棵树是二叉搜索树。

    第2个要删除的节点具有一个右子节点

    如果待删除的节点只存在一个右节点，我们依旧是使用托孤的方法，在知道了待删除的节点是父节点的左/右节点后，将待删除的节点的右子树连接到父节点上。同理如果要删除的节点是根节点，也和上面做一样的处理

    这里我再解释一下为什么，如果待删除节点是一个叶子节点时，也能归类到上面两种中的任意一种，因为将叶子节点的左子树还是右子树都是空。所以只用在删除了叶子节点后，让空代替叶子节点的位置即可。也可以使用“托孤”完美的解决

    第3个要删除的节点具有2个子节点

    但是如果我们要删除的那个节点是具有两个子节点的此时就不能使用”托孤“的方法了。依旧拿上面那张图举例子：

    这里我们假设要删除的是3号节点，此时的3号节点存在两个子节点，所以使用“托孤”的方法肯定是无法解决了。那么我们换一个思路能否寻找一个能够替代3号节点的节点呢？然后我们就会发现3号节点左子树的最大值，或者是右子树的最小值都能够替代三号节点（1号节点和4号节点），而我们在写代码的时候一般选择的是找到4号节点（右子树的最左节点，这里需要注意的是右子树的最左节点虽然已经不可能存在左子节点了，但还是可能会存在右子节点）。然后我们交换3和4，交换完成后的图如下：

    然后这里就变成了去删除3号节点（注意：使用待删除节点右子树的最左节点替换待删除的节点，这个待删除的节点一定会变成只有右子树或者是没有子树的情况）。

    下面我们就可以来写代码了

    1. bool Erase(const K& val)
    2. 	{
    3. 		//因为我们删除的这个节点可能是只有一个节点（0个节点）{这两种情况一起考虑}，具有2个子节点
    4. 		Node* cur = _root;
    5. 		//所以这里需要我们记录一下待删除那个节点的父节点
    6. 		Node* parent = nullptr;
    7. 		while (cur)
    8. 		{
    9. 			if (cur->_val < val)
    10. 			{
    11. 				parent = cur;
    12. 				cur = cur->_right;
    13. 			}
    14. 			else if (cur->_val > val)
    15. 			{
    16. 				parent = cur;
    17. 				cur = cur->_left;
    18. 			}
    19. 			else//找到了要删除的节点
    20. 			{
    21. 				//下面来考虑是一个子节点还是两个子节点的情况
    22. 				if (cur->_left == nullptr)//我没有左孩子，将我的右孩子托付给父节点
    23. 				{
    24. 					if (cur == _root)//我们要删除的这个节点刚好就是根节点
    25. 					{
    26. 						_root = cur->_right;
    27. 					}
    28. 					else//我们删除这个不是根节点,使用托孤法
    29. 					{
    30. 						if (cur == parent->_left)
    31. 						{
    32. 							parent->_left = cur->_right;
    33. 						}
    34. 						else
    35. 						{
    36. 							parent->_right = cur->_right;
    37. 						}
    38. 					}
    39. 				}
    40. 				else if (cur->_right == nullptr)//同理将我的左孩子托付给父节点
    41. 				{
    42. 					if (cur == _root)
    43. 					{
    44. 						_root = cur->_left;
    45. 					}
    46. 					else
    47. 					{
    48. 						if (cur == parent->_left)
    49. 						{
    50. 							parent->_left = cur->_left;
    51. 						}
    52. 						else
    53. 						{
    54. 							parent->_right = cur->_left;
    55. 						}
    56. 					}
    57. 				}
    58. 				else//我的左孩子和有孩子都存在值
    59. 				{
    60. 					//我需要去我的右子树里面找到最左值来替换我，然后再删除我
    61. 					Node* parent = cur;//这里parent就是为了能够找到交换后待删除节点的父节点的
    62. 					Node* subleft = cur->_right;
    63. 					while (subleft->_left)
    64. 					{
    65. 						parent = subleft;
    66. 						subleft = subleft->_left;
    67. 					}
    68. 					swap(subleft->_val, cur->_val);
    69. 					//下面就需要删除subleft节点
    70. 					//subleft是最左节点，但是它可能还具有右子节点
    71. 					if (subleft == parent->_left)
    72. 					{
    73. 						parent->_left = subleft->_right;
    74. 					}
    75. 					else
    76. 					{
    77. 						parent->_right = subleft->_right;
    78. 					}
    79. 				}
    80. 				return true;
    81. 			}
    82. 		}
    83. 		return false;//表明没有找到要删除的节点
    84. 	}

    这个代码需要注意一下的是这里：

    这里parent的目的已经写在注释中了，那么这里为什么要给parent赋值为cur而不是nullptr呢？如果这里的parent赋值的是nullptr，以上图的那棵树为例子，如果我们想要删除的是8号节点那么cur的右子节点刚好就是右子树的最左节点，此时就不会进入循环，如果parent为nullptr，那么后面就会出现对nullptr的解引用自然就会出现错误。所以这里我们给parent赋值cur，就是为了避免这种情况。如果给parent赋值为cur，依旧是上面的例子，此时的cur指向的就是8，然后我们交换8和10，然后使用parent将8的右子树连接到10上，完成对8的删除。

    下面我们来测试一下写的函数是否正确：

    以上我们就完成了，对二叉搜索树插入，查找，中序遍历，删除的模拟，但是除了中序遍历，以外都没有使用递归的方法，所以下面我们就使用递归的方法来模拟实现插入，查找和删除。

    查找函数（递归）

    我们需要记住要实现递归的一个大思路就是要将大问题分解化，例如这里假设我当前的这个节点没有找到你要查找的节点，那就根据你要查找值得大小将其分解成，去我的左子树/右子树里面去查找你要的节点下面是代码

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

    插入函数（递归）

    至于插入函数我们的第一步依旧是需要，找到要插入的位置，然后再连接，但是在使用递归的时候我们连接就不需要和非递归一样麻烦了。代码实现：

    1. 	bool InsertR(const K& val)
    2. 	{
    3. 		return _InsertR(_root,val);
    4. 	}
    5.   
    6.   bool _InsertR(Node*& cur,const K& val)//这里为什么要使用引用呢？
    7. 		//这里使用引用能够完成链接
    8. 	{
    9. 		if (cur == nullptr)
    10. 		{
    11. 			//这里的cur是一个别名是哪里的别名呢？是递归上一层的那个父节点left指针/right指针的别名，
    12.       //我们修改了这个cur自然就修改了
    13. 			//递归上一层的那个父节点的left/right指针完成了链接
    14. 			//即使你传过来的是一个nullptr这里就等于将这个空指针重新开辟了一个空间，并且改变了这个空指针的值
    15. 			cur = new Node(val);
    16. 			return true;
    17. 		}
    18. 		else
    19. 		{
    20. 			if (cur->_val < val)
    21. 			{
    22. 				return _InsertR(cur->_right, val);
    23. 			}
    24. 			else if(cur->_val>val)
    25. 			{
    26. 				return _InsertR(cur->_left, val);
    27. 			}
    28. 			else//遇到了相同的值不能插入
    29. 			{
    30. 				return false;
    31. 			}
    32. 		}
    33. 	}

    这里没有使用一个额外的变量来记录父节点，原因是我们使用了引用，而在非递归（循环）不能使用引用是因为在c++中引用是不能修改指向的。

    删除函数（递归）

    删除函数的递归实现思路是：如果当前节点不是待删除节点，那就递归去左子树和右子树上寻找，但是不同点依旧是使用了应用就不需要使用一个变量来记录父节点了。除此之外，还存在一个不同点在对于拥有两个子节点的待删除节点上，我们知道在将待删除节点和替换节点交换以后，整棵树不再是一个二叉搜索树（交换后引用也无法使用了）。

    但是我们在交换后，还有一个节点的左子树依旧是二叉搜索树。

    可以看到在将4和3交换后，4的右子树依旧是一颗二叉搜索树，所以我们就可以变成在交换节点的右子树上删除3号节点。

    下面是代码的实现：

    1. bool EraseR(const K& val)
    2. {
    3. 	return _EraseR(_root, val);
    4. }
    5. bool _EraseR(Node*& cur, const K& val)
    6. 	{
    7. 		if (cur == nullptr)
    8. 		{
    9. 			return false;//代表没找到要删除的数或者这棵树已经空了
    10. 		}
    11. 		else if (cur->_val < val)
    12. 		{
    13. 			return _EraseR(cur->_right, val);//转换成去我的右子树上删除这个节点
    14. 		}
    15. 		else if (cur->_val > val)
    16. 		{
    17. 			return _EraseR(cur->_left, val);//去我的左子树上去删除这个节点
    18. 		}
    19. 		else
    20. 		{
    21. 			//删除这个节点
    22. 			if (cur->_right == nullptr)
    23. 			{
    24. 				cur = cur->_left;
    25. 			}//这里还是使用了那个引用的特点此时的cur就是上一层父节点的（左子指针/右子指针）
    26. 			else if (cur->_left == nullptr)
    27. 			{
    28. 				cur = cur->_right;
    29. 			}
    30. 			else//代表要删除的这个节点具有两个节点
    31. 			{
    32. 				Node* subleft = cur->_right;
    33. 				while (subleft->_left)
    34. 				{
    35. 					subleft = subleft->_left;
    36. 				}
    37. 				swap(subleft->_val, cur->_val);//完成替换,那么下面就是一个重点此时我们的引用是无法改变的，也就意味着我们
    38. 				//无法把引用从cur替换到subleft的父节点上，那么此时我们又没有subleft的父节点，那么我们要怎么做呢？
    39. 				_EraseR(cur->_right, val);//我们就转换成去此时cur的右节点上删除val，虽然此时的整棵树不是一个
    40. 				//二分查找树，但是我们替换了之后的cur的右子树任然是一个二分查找树
    41. 				//原因如下，在交换前cur的值就小于右子树的所有值，那么我们将cur和右子树的最小值交换之后，
    42. 				//cur的右子树任然是满足二分搜索树的特点的
    43. 			}
    44. 		}
    45. 	}

    下面是我的所有包含在头文件中的代码（递归和非递归都有）

    1. template<class T>
    2. struct BSNode
    3. {
    4. 	BSNode* _left;
    5. 	BSNode* _right;
    6. 	T _val;
    7. 	BSNode(const T& a)
    8. 		:_val(a)
    9. 		,_left(nullptr)
    10. 		,_right(nullptr)
    11. 	{}
    12. };
    13.  
    14.  
    15. template<class K>
    16. class BStree
    17. {
    18. 	typedef BSNode<K> 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. 		//运行到这里代表这一棵树不是空树，我们需要找到这个val应该插入在什么地方
    29. 		Node* cur = _root;
    30. 		Node* parent = nullptr;//确保最后能够链接
    31. 		while (cur)
    32. 		{
    33. 			parent = cur;
    34. 			if (cur->_val < val)
    35. 			{
    36. 				cur = cur->_right;
    37. 			}
    38. 			else if (cur->_val > val)
    39. 			{
    40. 				cur = cur->_left;
    41. 			}
    42. 			else//默认情况下二叉搜索树是不允许出现重复值的
    43. 			{
    44. 				return false;
    45. 			}
    46. 		}
    47. 		if (val < parent->_val)//当运行到这里的时候，我们的cur已经移动到了val应该在的位置，此时parennt正是我的val需要的父节点
    48. 			//现在只需要判断val是大于parent的_val还是小于parent的_val
    49. 		{
    50. 			parent->_left = new Node(val);
    51. 			return true;
    52. 		}
    53. 		else
    54. 		{
    55. 			parent->_right = new Node(val);
    56. 			return true;
    57. 		}
    58. 	}
    59. 	void Inorder()
    60. 	{
    61. 		inorder(_root);//这里使用这种方法解决因为如果还是使用c语言的那种方法，会发现如果是在类外的话，我们无法
    62. 		//得到根节点，所以这里我们在创建一个函数来递归调用中序查看的方法
    63. 	}
    64. 	bool Find(const K& val)
    65. 	{
    66. 		Node* cur = _root;
    67. 		while (cur)
    68. 		{
    69. 			if (cur->_val < val)
    70. 			{
    71. 				cur = cur->_right;
    72. 			}
    73. 			else if (cur->_val > val)
    74. 			{
    75. 				cur = cur->_left;
    76. 			}
    77. 			else
    78. 			{
    79. 				return true;//代表找到了这个节点
    80. 			}
    81. 		}
    82. 		return false;//没有找到这个节点
    83. 	}
    84. 	bool Erase(const K& val)
    85. 	{
    86. 		//因为我们删除的这个节点可能是只有一个节点（0个节点）{这两种情况一起考虑}，具有2个子节点
    87. 		Node* cur = _root;
    88. 		//所以这里需要我们记录一下待删除那个节点的父节点
    89. 		Node* parent = nullptr;
    90. 		while (cur)
    91. 		{
    92. 			if (cur->_val < val)
    93. 			{
    94. 				parent = cur;
    95. 				cur = cur->_right;
    96. 			}
    97. 			else if (cur->_val > val)
    98. 			{
    99. 				parent = cur;
    100. 				cur = cur->_left;
    101. 			}
    102. 			else//找到了要删除的节点
    103. 			{
    104. 				//下面来考虑是一个子节点还是两个子节点的情况
    105. 				if (cur->_left == nullptr)//我没有左孩子，将我的右孩子托付给父节点
    106. 				{
    107. 					if (cur == _root)//我们要删除的这个节点刚好就是根节点
    108. 					{
    109. 						_root = cur->_right;
    110. 					}
    111. 					else//我们删除这个不是根节点,使用托孤法
    112. 					{
    113. 						if (cur == parent->_left)
    114. 						{
    115. 							parent->_left = cur->_right;
    116. 						}
    117. 						else
    118. 						{
    119. 							parent->_right = cur->_right;
    120. 						}
    121. 					}
    122. 				}
    123. 				else if (cur->_right == nullptr)//同理将我的左孩子托付给父节点
    124. 				{
    125. 					if (cur == _root)
    126. 					{
    127. 						_root = cur->_left;
    128. 					}
    129. 					else
    130. 					{
    131. 						if (cur == parent->_left)
    132. 						{
    133. 							parent->_left = cur->_left;
    134. 						}
    135. 						else
    136. 						{
    137. 							parent->_right = cur->_left;
    138. 						}
    139. 					}
    140. 				}
    141. 				else//我的左孩子和有孩子都存在值
    142. 				{
    143. 					//我需要去我的右子树里面找到最左值来替换我，然后再删除我
    144. 					Node* parent = cur;
    145. 					Node* subleft = cur->_right;
    146. 					while (subleft->_left)
    147. 					{
    148. 						parent = subleft;
    149. 						subleft = subleft->_left;
    150. 					}
    151. 					swap(subleft->_val, cur->_val);
    152. 					//下面就需要删除subleft节点
    153. 					//subleft是最左节点，但是它可能还具有右子节点
    154. 					if (subleft == parent->_left)
    155. 					{
    156. 						parent->_left = subleft->_right;
    157. 					}
    158. 					else
    159. 					{
    160. 						parent->_right = subleft->_right;
    161. 					}
    162. 				}
    163. 				return true;
    164. 			}
    165. 		}
    166. 		return false;//表明没有找到要删除的节点
    167. 	}
    168. 	//以上我们都是完成的非递归版本，下面我们来完成递归版本，除了中序遍历函数以外，都是非递归的
    169. 	bool InsertR(const K& val)
    170. 	{
    171. 		return _InsertR(_root,val);
    172. 	}
    173. 	bool FindR(const K& val)
    174. 	{
    175. 		return FindR(_root, val);
    176. 	}
    177. 	bool EraseR(const K& val)
    178. 	{
    179. 		return _EraseR(_root, val);
    180. 	}
    181. private:
    182. 	bool _EraseR(Node*& cur, const K& val)
    183. 	{
    184. 		if (cur == nullptr)
    185. 		{
    186. 			return false;//代表没找到要删除的数或者这棵树已经空了
    187. 		}
    188. 		else if (cur->_val < val)
    189. 		{
    190. 			return _EraseR(cur->_right, val);//转换成去我的右子树上删除这个节点
    191. 		}
    192. 		else if (cur->_val > val)
    193. 		{
    194. 			return _EraseR(cur->_left, val);//去我的左子树上去删除这个节点
    195. 		}
    196. 		else
    197. 		{
    198. 			//删除这个节点
    199. 			if (cur->_right == nullptr)
    200. 			{
    201. 				cur = cur->_left;
    202. 			}//这里还是使用了那个引用的特点此时的cur就是上一层父节点的（左子指针/右子指针）
    203. 			else if (cur->_left == nullptr)
    204. 			{
    205. 				cur = cur->_right;
    206. 			}
    207. 			else//代表要删除的这个节点具有两个节点
    208. 			{
    209. 				Node* subleft = cur->_right;
    210. 				while (subleft->_left)
    211. 				{
    212. 					subleft = subleft->_left;
    213. 				}
    214. 				swap(subleft->_val, cur->_val);//完成替换,那么下面就是一个重点此时我们的引用是无法改变的，也就意味着我们
    215. 				//无法把引用从cur替换到subleft的父节点上，那么此时我们又没有subleft的父节点，那么我们要怎么做呢？
    216. 				_EraseR(cur->_right, val);//我们就转换成去此时cur的右节点上删除val，虽然此时的整棵树不是一个
    217. 				//二分查找树，但是我们替换了之后的cur的右子树任然是一个二分查找树
    218. 				//原因如下，在交换前cur的值就小于右子树的所有值，那么我们将cur和右子树的最小值交换之后，
    219. 				//cur的右子树任然是满足二分搜索树的特点的
    220. 			}
    221. 		}
    222. 	}
    223. 	bool FindR(Node* cur, const K& val)
    224. 	{
    225. 		if (cur->_val == val)
    226. 		{
    227. 			return true;
    228. 		}
    229. 		else if (cur->_val < val)
    230. 		{
    231. 			return FindR(cur->_right, val);
    232. 		}
    233. 		else if (cur->_val > val)
    234. 		{
    235. 			return FindR(cur->_left, val);
    236. 		}
    237. 		return false;
    238. 	}
    239. 	bool _InsertR(Node*& cur,const K& val)//这里为什么要使用引用呢？
    240. 		//这里使用引用能够完成链接
    241. 	{
    242. 		if (cur == nullptr)
    243. 		{
    244. 			//这里的cur是一个别名是哪里的别名呢？是递归上一层的那个父节点left指针/right指针的别名，我们修改了这个cur自然就修改了
    245. 			//递归上一层的那个父节点的left/right指针完成了链接
    246. 			//即使你传过来的是一个nullptr这里就等于将这个空指针重新开辟了一个空间，并且改变了这个空指针的值
    247. 			cur = new Node(val);
    248. 			return true;
    249. 		}
    250. 		else
    251. 		{
    252. 			if (cur->_val < val)
    253. 			{
    254. 				return _InsertR(cur->_right, val);
    255. 			}
    256. 			else if(cur->_val>val)
    257. 			{
    258. 				return _InsertR(cur->_left, val);
    259. 			}
    260. 			else//遇到了相同的值不能插入
    261. 			{
    262. 				return false;
    263. 			}
    264. 		}
    265. 	}
    266. 	void inorder(Node* _root)
    267. 	{
    268. 		if (_root == nullptr)
    269. 		{
    270. 			return;
    271. 		}
    272. 		inorder(_root->_left);
    273. 		cout << _root->_val << " ";
    274. 		inorder(_root->_right);
    275. 	}
    276. 	Node* _root = nullptr;
    277. };//一棵二叉树只会具有一个根节点

    希望这篇博客能对你有所帮助，写得不好请见谅，如果发现了错误，欢迎指正。

  • 相关阅读:
    sample函数—R语言
    应用层-HTTP协议
    【苹果家庭推送iMessage】软件安装应用程序访问HealthKit HomeKit
    SpringCloud-NacosFoundation
    【Prometheus】Node Exporter常用查询PromQL 语句大总结
    androdi知识笔记
    PHP安全特性
    java毕业设计宠物交易mybatis+源码+调试部署+系统+数据库+lw
    最「难搞」的英伟达也开源了，下一个会是谁？
    手撕LRU缓存——LinkedHashMap简易源码
  • 原文地址：https://blog.csdn.net/D223546/article/details/134025946