• 【C++ STL】-- 二叉搜索树

    目录

    二叉搜索树概念

    二叉搜索树的应用

    二叉搜索树的实现（K模型）

    构造函数

    默认拷贝构造函数

    赋值运算符重载函数

    普通写法：

    进阶写法：

    析构函数

    验证是否遵循搜索二叉树规则  

    插入函数（Insert）的实现

    常规实现：

    递归实现：

    删除函数（Erase）的实现

    常规实现： 

    递归实现：

    查找函数（Find）的实现

    常规实现：

    递归实现：

    二叉搜索树的性能分析

    代码汇总

    二叉搜索树概念

            所谓二叉树（binary tree），其意义是：“任意节点最多只允许两个子节点”。这两个子节点称为左子节点和右子节点。

            所谓二叉搜索树（binary search tree），可提供对数时间（logarithmic time）的元素插入和访问。

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

    二叉搜索树的应用

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

    的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树。
    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

    K模型节点结构：

    1. template<class K>
    2. struct BSTreeNode
    3. {
    4. 	BSTreeNode* _left;
    5. 	BSTreeNode* _right;
    6. 	K _key;
    7.  
    8. 	BSTreeNode(const K& key)
    9. 		:_left(nullptr)
    10. 		, _right(nullptr)
    11. 		, _key(key)
    12. 	{}
    13. };

            KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方

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

    KV模型节点结构：

    1. template<class K, class V>
    2. struct BSTreeNode
    3. {
    4. 	BSTreeNode* _left;
    5. 	BSTreeNode* _right;
    6. 	K _key;
    7. 	V _value;
    8.  
    9. 	BSTreeNode(const K& key, const V& value)
    10. 		:_left(nullptr)
    11. 		, _right(nullptr)
    12. 		, _key(key)
    13. 		, _value(value)
    14. 	{}
    15. };

    二叉搜索树的实现（K模型）

    （KV模型同样思维）

    • 便于实现函数接口，将类 BSTreeNode 进行重命名。
    • 定义一个 BSTreeNode* 类型的_root作为头节点。
    1. template<class K>
    2. struct BSTreeNode
    3. {
    4. 	BSTreeNode* _left;
    5. 	BSTreeNode* _right;
    6. 	K _key;
    7.  
    8. 	BSTreeNode(const K& key)
    9. 		:_left(nullptr)
    10. 		, _right(nullptr)
    11. 		, _key(key)
    12. 	{}
    13. };
    14.  
    15. template<class K>
    16. struct BSTree
    17. {
    18. 	typedef BSTreeNode Node; //便于后期使用
    19.  
    20.     //…………（实现函数）
    21.  
    22. 	Node* _root = nullptr; //头节点
    23. };

    构造函数

            使用编译器自动生成的即可。但是，由于需要写拷贝构造函数，所以要强制编译器生成默认的构造。

    1. // C++的用法：强制编译器生成默认的构造
    2. BSTree() = default;

    默认拷贝构造函数

            利用前序递归。赋值并按相同顺序链接。

    1. BSTree(const BSTree& t)
    2. {
    3. 	_root = _Copy(t._root);
    4. }
    5. 		
    6. Node* _Copy(Node* root)
    7. {
    8. 	if (root == nullptr)
    9. 	{
    10. 		return nullptr;
    11. 	}
    12.  
    13. 	Node* copyRoot = new Node(root->_key);
    14. 	copyRoot->_left = _Copy(root->_left);
    15. 	copyRoot->_right = _Copy(root->_right);
    16. 	return copyRoot;
    17. }

    赋值运算符重载函数

    普通写法：

            利用前序递归。赋值并按相同顺序链接。

    1. const BSTree& operator=(const BSTree& t)
    2. {
    3. 	if (this != &t) //防止自己给自己赋值
    4. 	{
    5. 		_root = _Copy(t._root);
    6. 	}
    7. 	return *this;
    8. }
    9.  
    10. Node* _Copy(Node* root)
    11. {
    12. 	if (root == nullptr)
    13. 	{
    14. 		return nullptr;
    15. 	}
    16.     
    17.     //利用前序递归
    18. 	Node* copyRoot = new Node(root->_key);
    19. 	copyRoot->_left = _Copy(root->_left);
    20. 	copyRoot->_right = _Copy(root->_right);
    21. 	return copyRoot;
    22. }

    进阶写法：

            利用临时变量t进行接收，通过t可以间接调用BSTree的拷贝构造函数完成拷贝构造出t。然后只需要将，拷贝构造出来的对象的二叉搜索树头节点与this对象的二叉搜索树头节点进行交换，而对象t会在该赋值运算符重载函数调用结束时自动析构。

    1. // 利用t间接调用拷贝构造函数，后赋值给this->_root
    2. BSTree& operator=(BSTree t)
    3. {
    4. 	swap(_root, t._root);
    5. 	return *this;
    6. }

    析构函数

             对于析构函数，需要将每一个节点都进行释放。所以需要利用后序释放。从下面的节点开始进行释放空间。

    1. //释放树中结点
    2. void Destory(Node* root)
    3. {
    4. 	if (root == nullptr)
    5. 		return;
    6.  
    7.     // 释放左子树中的结点
    8. 	Destory(root->_left); 
    9.     // 释放右子树中的结点
    10. 	Destory(root->_right);
    11. 	delete root;
    12.     root = nullptr;
    13. }
    14.  
    15. ~BSTree()
    16. {
    17.     //递归实现删除
    18. 	Destory(_root);
    19. 	_root = nullptr;
    20. }

    验证是否遵循搜索二叉树规则  

            已知，搜索二叉树一定遵循左子树所有节点一定小于根节点，右子树所有节点一定大于根节点，所以可以利用中序的方式，打印二叉树，打印出来的一定为升序。

    1. // this指针没法实现递归
    2. void InOrder()
    3. {
    4.     // 实现递归
    5. 	_InOrder(_root);
    6. 	cout << endl;
    7. }
    8. // 中序遍历
    9. void _InOrder(Node* root)
    10. {
    11. 	if (root == nullptr)
    12. 		return;
    13. 	_InOrder(root->_left);
    14. 	cout << root->_key << " ";
    15. 	_InOrder(root->_right);
    16. }

    插入函数（Insert）的实现

    二叉搜索树的插入

    1. 树为空，则直接新增节点，赋值给root指针。
    2. 树不空，按二叉搜索树性质查找插入位置，插入新节点。

    常规实现：

    若不是空树，插入结点的具体操作如下：

    1. 若待插入结点的值等于根结点的值，则插入结点失败。
    2. 若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中。
    3. 若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中。

    (因为二查搜索树一个数只能存储一次，所以循环到空即一定是可以插入的)

    1. // 根据二叉搜索树的性质查找：找到值为key的节点在二叉搜索树中的位置
    2. bool Insert(const K& key)
    3. {
    4. 	// 如果树为空，直接插入
    5. 	if (_root == nullptr)
    6. 	{
    7. 		_root = new Node(key);
    8. 		return true;
    9. 	}
    10.  
    11. 	// 按照二叉搜索树的性质查找key在树中的插入位置cur
    12. 	Node* cur = _root;
    13. 	// 记录cur的双亲，因为新元素最终插入在cur双亲左右孩子的位置
    14. 	Node* parent = nullptr;
    15. 	while (cur)
    16. 	{
    17. 		if (cur->_key > key)
    18. 		{
    19. 			parent = cur;
    20. 			cur = cur->_left;
    21. 		}
    22. 		else if (cur->_key < key)
    23. 		{
    24. 			parent = cur;
    25. 			cur = cur->_right;
    26. 		}
    27. 		else // 元素已经在树中存在
    28. 			return false;
    29. 	}
    30.  
    31. 	// 插入元素
    32. 	cur = new Node(key);
    33. 	// 因为新元素最终插入在cur双亲左右孩子的位置,所以进行连接
    34. 	if (parent->_key < key)
    35. 		parent->_right = cur;
    36. 	else
    37. 		parent->_left = cur;
    38.  
    39. 	return true;
    40. }

    递归实现：

            与常规实现，本质上没有区别，只不过是将循环寻找变为递归的形式。在右就递归右，在左就递归左。

    1. // this指针没法实现递归
    2. bool InsertR(const K& key)
    3. {
    4. 	// 实现递归
    5. 	return _InsertR(_root, key);
    6. }
    7.  
    8. bool _InsertR(Node*& root, const K& key)
    9. {
    10. 	//找到了插入的位置
    11. 	if (root == nullptr)
    12. 	{
    13. 		root = new Node(key);
    14. 		return true;
    15. 	}
    16.  
    17. 	// 查找插入位置
    18. 	if (root->_key > key)
    19. 		_InsertR(root->_left, key);
    20. 	else if (root->_key < key)
    21. 		_InsertR(root->_right, key);
    22. 	else // 该值已有
    23. 		return false;
    24. }

    删除函数（Erase）的实现

      二叉搜索树的删除
            首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面种四情况：
    1. 要删除的结点无孩子结点。
    2. 要删除的结点只有左孩子结点。
    3. 要删除的结点只有右孩子结点。
    4. 要删除的结点有左、右孩子结点。

    常规实现： 

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

            1、删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除。

    正常情况：

    特例情况 ：

            2、删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除。

    正常情况：

     特例情况 ：

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

    1. bool Erase(const K& key)
    2. {
    3. 	// 如果树为空，删除失败
    4. 	if (nullptr == _root)
    5. 		return false;
    6.  
    7. 	// 按照二叉搜索树的性质查找key在树中的位置cur
    8. 	Node* cur = _root;
    9. 	// 记录cur的双亲，因为删除cur后cur双亲连接cur的左右孩子
    10. 	Node* parent = nullptr;
    11. 	while (cur)
    12. 	{
    13. 		// 查找key在树中的位置
    14. 		if (cur->_key > key)
    15. 		{
    16. 			parent = cur;
    17. 			cur = cur->_left;
    18. 		}
    19. 		else if (cur->_key < key)
    20. 		{
    21. 			parent = cur;
    22. 			cur = cur->_right;
    23. 		}
    24. 		else // 找到了
    25. 		{
    26. 			if (cur->_right == nullptr)// 找到的节点，只有右子树时
    27. 			{
    28. 				// 找到的节点时头节点时，改变头节点
    29. 				if (cur == _root)
    30. 					_root = cur->_left;
    31. 				else
    32. 				{
    33. 					if (parent->_left == cur)
    34. 						parent->_left = cur->_left;
    35. 					else
    36. 						parent->_right = cur->_left;
    37. 				}
    38. 				delete cur;
    39. 				cur = nullptr;
    40. 			}
    41. 			else if (cur->_left == nullptr)// 找到的节点，只有左子树时
    42. 			{
    43. 				// 找到的节点时头节点时，改变头节点
    44. 				if (cur == _root)
    45. 					_root = cur->_right;
    46. 				else
    47. 				{
    48. 					if (parent->_left == cur)
    49. 						parent->_left = cur->_right;
    50. 					else
    51. 						parent->_right = cur->_right;
    52. 				}
    53. 			}
    54. 			else
    55. 			{
    56. 				//找右子树的最小值节点，进行替换
    57. 				Node* minParent = cur;
    58. 				Node* min = cur->_right;
    59. 				while (min->_left)
    60. 				{
    61. 					minParent = min;
    62. 					min = min->_left;
    63. 				}
    64. 				swap(min->_key, cur->_key);
    65.  
    66. 				if (min == minParent->_left)
    67. 					minParent->_left = min->_right;
    68. 				else
    69. 					minParent->_right = min->_left;
    70.  
    71. 				delete min;
    72. 			}
    73.  
    74. 			return true;
    75. 		}
    76. 	}
    77. 	return false;
    78. }

    递归实现：

    1. // this指针没法实现递归
    2. bool EraseR(const K& key)
    3. {
    4. 	// 实现递归
    5. 	return _EraseR(_root, key);
    6. }
    7.  
    8. bool _EraseR(Node*& root, const K& key)
    9. {
    10. 	if (root == nullptr)
    11. 		return false;
    12.  
    13. 	// 查找key在树中的位置
    14. 	if (root->_key > key)
    15. 		return _EraseR(root->_left, key);
    16. 	else if (root->_key < key)
    17. 		return _EraseR(root->_right, key);
    18. 	else
    19. 	{
    20. 		Node* del = root;
    21. 		if (root->_left == nullptr)
    22. 			root = root->_right;
    23. 		else if (root->_right == nullptr)
    24. 			root = root->_left;
    25. 		else
    26. 		{
    27. 			//找右子树的最小值节点，进行替换
    28. 			Node* min = root->_right;
    29. 			while (min->_left)
    30. 				min = min->_left;
    31. 			swap(root->_key, min->_key);
    32.  
    33. 			return _EraseR(root->_right, key); //此时删除key，是root->_left == nullptr的情况
    34. 		}
    35. 		// 删除
    36. 		delete del;
    37. 		del = nullptr;
    38. 		return true;
    39. 	}
    40. }

            对于第1、2种情况：与常规实现的没区别，只是由于，常规实现使用的是局部变量cur，所以需要使用局部变量parent来确保链接情况以及是否为根节点，但是由于递归实现，直接就可以直接更改其节点的地址，所以底层差不多，而表面就一条语句。

             对于第3种情况：思维与常规是类似的，但是我们需要删除就需要利用前面的第1、2种情况操作。

    • 首先找到后，找其右子树的最左节点（大于其的最小值）

    • 掉换_key

    • 再次递归找到_key，此时删除_key，此时就是第1类情况。

    查找函数（Find）的实现

    二叉搜索树的查找

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

    常规实现：

    1. // 根据二叉搜索树的性质查找：找到值为key的节点在二叉搜索树中的位置
    2. bool Find(const K& key)
    3. {
    4. 	Node* cur = _root;
    5. 	while (cur)
    6. 	{
    7. 		// 查找key在树中的位置
    8. 		if (cur->_key > key)
    9. 			cur = cur->_left;
    10. 		else if (cur->_key < key)
    11. 			cur = cur->_right;
    12. 		else // 找到了
    13. 			return true;
    14. 	}
    15. 	return false;
    16. }

    递归实现：

    1. // this指针没法实现递归
    2. bool FindR(const K& key)
    3. {
    4. 	// 实现递归
    5. 	return _FindR(_root, key);
    6. }
    7.  
    8. bool _FindR(const Node* root, const K& key)
    9. {
    10. 	if (root == nullptr)
    11. 		return false;
    12.  
    13. 	// 查找key在树中的位置
    14. 	if (root->_key > key) // >即只有可能在左树
    15. 		return _FindR(root->_left, key);
    16. 	else if (root->_key < key) // <即只有可能在左树
    17. 		return _FindR(root->_right, key);
    18. 	else // 找到了
    19. 		return true;
    20.  
    21. 	return false;
    22. }

    二叉搜索树的性能分析

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

     

     

    • 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log2N
    • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：n^2
            问题：如果退化成单支树，二叉搜索树的性能就失去了。二叉搜索树的性能能否达到最优,二叉树左右子树的高度差就是关键，AVL树和红黑树就是通过旋转来平衡高度差，以此提高二叉搜索树性能。

    代码汇总

    1. #include
    2. using namespace std;
    3. namespace cr
    4. {
    5. 	template<class K>
    6. 	struct BSTreeNode
    7. 	{
    8. 		BSTreeNode* _left;
    9. 		BSTreeNode* _right;
    10. 		K _key;
    11.  
    12. 		BSTreeNode(const K& key)
    13. 			:_left(nullptr)
    14. 			, _right(nullptr)
    15. 			, _key(key)
    16. 		{}
    17. 	};
    18.  
    19. 	template<class K>
    20. 	struct BSTree
    21. 	{
    22. 		typedef BSTreeNode Node;
    23.  
    24. 		// C++的用法：强制编译器生成默认的构造
    25. 		BSTree() = default;
    26.  
    27. 		BSTree(const BSTree& t)
    28. 		{
    29. 			_root = _Copy(t._root);
    30. 		}
    31.  
    32. 		Node* _Copy(Node* root)
    33. 		{
    34. 			if (root == nullptr)
    35. 			{
    36. 				return nullptr;
    37. 			}
    38.  
    39. 			Node* copyRoot = new Node(root->_key);
    40. 			copyRoot->_left = _Copy(root->_left);
    41. 			copyRoot->_right = _Copy(root->_right);
    42. 			return copyRoot;
    43. 		}
    44.  
    45. 		//const BSTree& operator=(const BSTree& t)
    46. 		//{
    47. 		//	if (this != &t) //防止自己给自己赋值
    48. 		//	{
    49. 		//		_root = _Copy(t._root);
    50. 		//	}
    51. 		//	return *this;
    52. 		//}
    53.  
    54. 		// 利用t间接调用拷贝构造函数，后赋值给this->_root
    55. 		BSTree& operator=(BSTree t)
    56. 		{
    57. 			swap(_root, t._root);
    58. 			return *this;
    59. 		}
    60.  
    61. 		//释放树中结点
    62. 		void Destory(Node* root)
    63. 		{
    64. 			if (root == nullptr)
    65. 				return;
    66.  
    67. 			// 释放左子树中的结点
    68. 			Destory(root->_left);
    69. 			// 释放右子树中的结点
    70. 			Destory(root->_right);
    71. 			delete root;
    72. 			root = nullptr;
    73. 		}
    74.  
    75. 		~BSTree()
    76. 		{
    77. 			//递归实现删除
    78. 			Destory(_root);
    79. 			_root = nullptr;
    80. 		}
    81. 		
    82. 		// 根据二叉搜索树的性质查找：找到值为key的节点在二叉搜索树中的位置
    83. 		bool Insert(const K& key)
    84. 		{
    85. 			// 如果树为空，直接插入
    86. 			if (_root == nullptr)
    87. 			{
    88. 				_root = new Node(key);
    89. 				return true;
    90. 			}
    91.  
    92. 			// 按照二叉搜索树的性质查找key在树中的插入位置cur
    93. 			Node* cur = _root;
    94. 			// 记录cur的双亲，因为新元素最终插入在cur双亲左右孩子的位置
    95. 			Node* parent = nullptr;
    96. 			while (cur)
    97. 			{
    98. 				if (cur->_key > key)
    99. 				{
    100. 					parent = cur;
    101. 					cur = cur->_left;
    102. 				}
    103. 				else if (cur->_key < key)
    104. 				{
    105. 					parent = cur;
    106. 					cur = cur->_right;
    107. 				}
    108. 				else // 元素已经在树中存在
    109. 					return false;
    110. 			}
    111.  
    112. 			// 插入元素
    113. 			cur = new Node(key);
    114. 			// 因为新元素最终插入在cur双亲左右孩子的位置,所以进行连接
    115. 			if (parent->_key < key)
    116. 				parent->_right = cur;
    117. 			else
    118. 				parent->_left = cur;
    119.  
    120. 			return true;
    121. 		}
    122.  
    123. 		// 根据二叉搜索树的性质查找：找到值为key的节点在二叉搜索树中的位置
    124. 		bool Find(const K& key)
    125. 		{
    126. 			Node* cur = _root;
    127. 			while (cur)
    128. 			{
    129. 				// 查找key在树中的位置
    130. 				if (cur->_key > key)
    131. 					cur = cur->_left;
    132. 				else if (cur->_key < key)
    133. 					cur = cur->_right;
    134. 				else // 找到了
    135. 					return true;
    136. 			}
    137. 			return false;
    138. 		}
    139.  
    140. 		bool Erase(const K& key)
    141. 		{
    142. 			// 如果树为空，删除失败
    143. 			if (nullptr == _root)
    144. 				return false;
    145.  
    146. 			// 按照二叉搜索树的性质查找key在树中的位置cur
    147. 			Node* cur = _root;
    148. 			// 记录cur的双亲，因为删除cur后cur双亲连接cur的左右孩子
    149. 			Node* parent = nullptr;
    150. 			while (cur)
    151. 			{
    152. 				// 查找key在树中的位置
    153. 				if (cur->_key > key)
    154. 				{
    155. 					parent = cur;
    156. 					cur = cur->_left;
    157. 				}
    158. 				else if (cur->_key < key)
    159. 				{
    160. 					parent = cur;
    161. 					cur = cur->_right;
    162. 				}
    163. 				else // 找到了
    164. 				{
    165. 					if (cur->_right == nullptr)// 找到的节点，只有右子树时
    166. 					{
    167. 						// 找到的节点时头节点时，改变头节点
    168. 						if (cur == _root)
    169. 							_root = cur->_left;
    170. 						else
    171. 						{
    172. 							if (parent->_left == cur)
    173. 								parent->_left = cur->_left;
    174. 							else
    175. 								parent->_right = cur->_left;
    176. 						}
    177. 						delete cur;
    178. 						cur = nullptr;
    179. 					}
    180. 					else if (cur->_left == nullptr)// 找到的节点，只有左子树时
    181. 					{
    182. 						// 找到的节点时头节点时，改变头节点
    183. 						if (cur == _root)
    184. 							_root = cur->_right;
    185. 						else
    186. 						{
    187. 							if (parent->_left == cur)
    188. 								parent->_left = cur->_right;
    189. 							else
    190. 								parent->_right = cur->_right;
    191. 						}
    192. 					}
    193. 					else
    194. 					{
    195. 						//找右子树的最小值节点，进行替换
    196. 						Node* minParent = cur;
    197. 						Node* min = cur->_right;
    198. 						while (min->_left)
    199. 						{
    200. 							minParent = min;
    201. 							min = min->_left;
    202. 						}
    203. 						swap(min->_key, cur->_key);
    204.  
    205. 						if (min == minParent->_left)
    206. 							minParent->_left = min->_right;
    207. 						else
    208. 							minParent->_right = min->_left;
    209.  
    210. 						delete min;
    211. 					}
    212.  
    213. 					return true;
    214. 				}
    215. 			}
    216. 			return false;
    217. 		}
    218.  
    219. 		void InOrder()
    220. 		{
    221. 			_InOrder(_root);
    222. 			cout << endl;
    223. 		}
    224.  
    225. 		//递归版本
    226.  
    227. 		// this指针没法实现递归
    228. 		bool FindR(const K& key)
    229. 		{
    230. 			// 实现递归
    231. 			return _FindR(_root, key);
    232. 		}
    233.  
    234. 		// this指针没法实现递归
    235. 		bool EraseR(const K& key)
    236. 		{
    237. 			// 实现递归
    238. 			return _EraseR(_root, key);
    239. 		}
    240.  
    241. 		// this指针没法实现递归
    242. 		bool InsertR(const K& key)
    243. 		{
    244. 			// 实现递归
    245. 			return _InsertR(_root, key);
    246. 		}
    247.  
    248. 	private:
    249. 		//中序输出
    250. 		void _InOrder(Node* root)
    251. 		{
    252. 			if (root == nullptr)
    253. 				return;
    254. 			_InOrder(root->_left);
    255. 			cout << root->_key << " ";
    256. 			_InOrder(root->_right);
    257. 		}
    258.  
    259. 		bool _FindR(const Node* root, const K& key)
    260. 		{
    261. 			if (root == nullptr)
    262. 				return false;
    263.  
    264. 			// 查找key在树中的位置
    265. 			if (root->_key > key) // >即只有可能在左树
    266. 				return _FindR(root->_left, key);
    267. 			else if (root->_key < key) // <即只有可能在左树
    268. 				return _FindR(root->_right, key);
    269. 			else // 找到了
    270. 				return true;
    271.  
    272. 			return false;
    273. 		}
    274.  
    275. 		bool _EraseR(Node*& root, const K& key)
    276. 		{
    277. 			if (root == nullptr)
    278. 				return false;
    279.  
    280. 			// 查找key在树中的位置
    281. 			if (root->_key > key)
    282. 				return _EraseR(root->_left, key);
    283. 			else if (root->_key < key)
    284. 				return _EraseR(root->_right, key);
    285. 			else
    286. 			{
    287. 				Node* del = root;
    288. 				if (root->_left == nullptr)
    289. 					root = root->_right;
    290. 				else if (root->_right == nullptr)
    291. 					root = root->_left;
    292. 				else
    293. 				{
    294. 					//找右子树的最小值节点，进行替换
    295. 					Node* min = root->_right;
    296. 					while (min->_left)
    297. 						min = min->_left;
    298. 					swap(root->_key, min->_key);
    299. 					// 此时删除key，是root->_left == nullptr的情况
    300. 					return _EraseR(root->_right, key);
    301. 				}
    302. 				// 删除
    303. 				delete del;
    304. 				del = nullptr;
    305. 				return true;
    306. 			}
    307. 		}
    308.  
    309. 		bool _InsertR(Node*& root, const K& key)
    310. 		{
    311. 			//找到了插入的位置
    312. 			if (root == nullptr)
    313. 			{
    314. 				root = new Node(key);
    315. 				return true;
    316. 			}
    317.  
    318. 			// 查找插入位置
    319. 			if (root->_key > key)
    320. 				_InsertR(root->_left, key);
    321. 			else if (root->_key < key)
    322. 				_InsertR(root->_right, key);
    323. 			else // 该值已有
    324. 				return false;
    325. 		}
    326.  
    327. 		Node* _root = nullptr;
    328. 	};
    329.  
    330. }
  • 相关阅读:
    加快访问github的速度解决方案
    Android JKS MD5 SHA1 公钥生成 私钥生成 APP备案 内容获取
    低代码平台搭建跨部门沟通系统案例分析
    GIS工具maptalks开发手册(二)01-11——渲染文字及参数注释
    Linux系统连接华为oceanstor数据存储
    121. 买卖股票的最佳时机 --力扣 --JAVA
    Java基础之《netty（1）—netty介绍》
    Web大学生网页作业成品——抗击疫情网站设计与实现(HTML+CSS)实训素材
    21天打卡挑战学习MySQL——《SQL基础入门》第二周 第四篇
    小程序如何部署SSL证书
  • 原文地址：https://blog.csdn.net/weixin_64609308/article/details/128018280