• 【数据结构高阶】二叉搜索树

    接下来我们来开始使用C++来详细讲解数据结构的一些高阶的知识点

    本期讲解的是二叉搜索树，对于初阶二叉树有所遗忘的同学可以看到这里：

    【精选】【数据结构初阶】链式二叉树的解析及一些基本操作

    讲解二叉搜索树主要是为了后面的map和set做铺垫，废话不多说我们直接上干货：

    目录

    一、二叉搜索树的概念

    二、模拟实现二叉搜索树

    2.1 插入数据

    2.1.1 插入数据的非递归实现

    2.2 遍历数据

    2.3 查找数据

    2.4 删除数据

    2.4.1 删除数据的非递归实现

    2.5 二叉搜索树的析构

    2.6 二叉搜索树的拷贝构造

    2.7 赋值重载

    2.8 模拟实现二叉搜索树的全部代码

    三、二叉搜索树的应用

    四、二叉搜索树的性能分析

    一、二叉搜索树的概念

    二叉搜索树又称二叉排序树（BST， Binary Search Tree），它可以是一棵空树，或者是具有以下性质的二叉树：

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

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

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

     例如：

    我们可以发现的一点：无论是什么样的二叉搜索树，使用中序遍历，遍历出的值都是升序排列的

    二、模拟实现二叉搜索树

    下面又到了我们最激动人心的代码实现环节，本次代码实现我们还是要基于链式二叉树的实现：

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

    2.1 插入数据

    我们可以根据二叉搜索树的规律来向其中插入数据，但是插入数据时需要注意一点：要记录插入节点的上一个父节点，将插入的节点连接上二叉树：

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool Insert(const K& key)
    7. 	{
    8. 		if (_root == nullptr)
    9. 		{
    10. 			_root = new Node(key);
    11. 			_root->_key = key;
    12. 			return true;
    13. 		}
    14. 		Node* cur = _root;//使用cur遍历二叉树找到合适的插入位置
    15. 		Node* parent = cur;//记录cur的父节点
    16. 		while (cur)
    17. 		{
    18. 			parent = cur;
    19. 			if (key < cur->_key)
    20. 			{
    21. 				cur = cur->_lchild;
    22. 			}
    23. 			else if (key > cur->_key)
    24. 			{
    25. 				cur = cur->_rchild;
    26. 			}
    27. 			else
    28. 			{
    29. 				return false;//这里创建的二叉搜索树不允许出现值的冗余
    30. 			}
    31. 		}
    32. 		cur = new Node(key);//创建
    33. 		//将创建的节点链接到二叉树上
    34. 		if (key < parent->_key)
    35. 		{
    36. 			parent->_lchild = cur;
    37. 		}
    38. 		else
    39. 		{
    40. 			parent->_rchild = cur;
    41. 		}
    42. 		return true;
    43. 	}
    44.  
    45. private:
    46. 	Node* _root = nullptr;//根节点
    47. };

    2.1.1 插入数据的非递归实现

    递归的效率并没有循环高，那为什么要说一下插入数据的非递归实现呢

    主要是非递归的数据插入的传值方法值得一说：

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool InsertR(const K& key)//插入数据(递归)
    7. 	{
    8. 		return _InsertR(_root, key);
    9. 	}
    10.  
    11. 	bool _InsertR(Node*& root,const K& key)//这里使用指针的引用用来直接修改其父节点指针的指向
    12. 	{
    13. 		if (root == nullptr)
    14. 		{
    15. 			root = new Node(key);
    16. 			return true;
    17. 		}
    18. 		if (root->_key > key)
    19. 		{
    20. 			_InsertR(root->_lchild, key);
    21. 		}
    22. 		else if (root->_key < key)
    23. 		{
    24. 			_InsertR(root->_rchild, key);
    25. 		}
    26. 		else
    27. 		{
    28. 			return false;
    29. 		}
    30. 	}
    31. private:
    32. 	Node* _root = nullptr;//根节点
    33. };

    我们可以看到在递归时，传入的形参类型为Node*&，这样可以直接在其函数内部习惯其父节点孩子指针的指向

    那为什么要写两个插入函数呢？因为如果我们直接使用_InsertR函数，无法直接使用对象对_InsertR函数进行传参

    2.2 遍历数据

    因为二叉搜索树的性质，这里我们采用中序遍历： 

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool Insert(const K& key)插入数据
    7. 	{
    8.         ....
    9. 	}
    10.  
    11. 	void InOrder()//中序遍历
    12. 	{
    13. 		_InOrder(_root);
    14. 		cout << endl;
    15. 	}
    16.  
    17. 	void _InOrder(Node* root)
    18. 	{
    19. 		if (root == NULL)//如果是空树就直接结束
    20. 		{
    21. 			return;
    22. 		}
    23. 		_InOrder(root->_lchild);//先递归遍历其左子树
    24. 		cout << root->_key << " ";//再遍历其根节点
    25. 		_InOrder(root->_rchild);//最后递归遍历其右子树
    26. 	}
    27.  
    28. private:
    29. 	Node* _root = nullptr;//根节点
    30. };

    那为什么要写两个中序遍历函数呢？因为如果我们直接使用_InOrder函数，无法直接使用对象对_InOrder函数进行传参

    2.3 查找数据

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool Insert(const K& key)//插入数据
    7. 	{
    8.         ......
    9. 	}
    10.  
    11. 	void InOrder()//中序遍历
    12. 	{
    13.         ......
    14. 	}
    15.  
    16. 	void _InOrder(Node* root)
    17. 	{
    18.         ......
    19. 	}
    20.  
    21. 	bool Find(const K& key)//查找数据
    22. 	{
    23. 		Node* cur = _root;
    24. 		while (cur)
    25. 		{
    26. 			if (cur->_key < key)
    27. 			{
    28. 				cur = cur->_rchild;
    29. 			}
    30. 			else if (cur->_key > key)
    31. 			{
    32. 				cur = cur->_lchild;
    33. 			}
    34. 			else
    35. 			{
    36. 				return true;
    37. 			}
    38. 		}
    39. 		return false;
    40. 	}
    41.  
    42. private:
    43. 	Node* _root = nullptr;//根节点
    44. };

    2.4 删除数据

    对于在二叉搜索树中删除数据，我们就要好好说道说道了

    下面我们有这样的一个二叉搜索树：

    现在我们要删除其叶子节点，这很容易，直接删除完，再将其父节点对应的孩子指针置空即可

    那我们要删只有一个孩子节点的数据呢？例如14和10

    这个稍微麻烦一点，删除完该节点后将其孩子节点托付给其父节点即可：

    那要删带有两个孩子节点的数据呢？例如3、6、8：

    对于这种情况我们可以选择其节点下的左子树的最大节点（左子树的最右节点），或者右子树的最小节点（右子树的最左节点）来替代要删除的节点：

    综上所述，要删除的结点可能分下面四种情况：

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

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

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

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

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

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

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

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

    思路我们有了，下面用代码来实现一下：

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool Insert(const K& key)//插入数据
    7. 	{
    8.         ...
    9. 	}
    10.  
    11. 	void InOrder()//中序遍历
    12. 	{
    13.         ...
    14. 	}
    15.  
    16. 	void _InOrder(Node* root)
    17. 	{
    18.         ...
    19. 	}
    20.  
    21. 	bool Find(const K& key)//查找数据
    22. 	{
    23.         ...
    24. 	}
    25.  
    26. 	bool Erase(const K& key)
    27. 	{
    28. 		Node* cur = _root;//使用cur遍历二叉树找到要删除元素的位置
    29. 		Node* parent = cur;//记录cur的父节点
    30. 		while (cur)//寻找需要删除的节点
    31. 		{
    32. 			if (cur->_key < key)
    33. 			{
    34. 				parent = cur;
    35. 				cur = cur->_rchild;
    36. 			}
    37. 			else if (cur->_key > key)
    38. 			{
    39. 				parent = cur;
    40. 				cur = cur->_lchild;
    41. 			}
    42. 			else//找到了,开始删除
    43. 			{
    44. 				if (cur->_lchild == cur->_rchild && cur->_lchild == nullptr)//删除的节点为叶子节点
    45. 				{
    46. 					if (parent == cur)//删除的是根节点
    47. 					{
    48. 						_root = nullptr;//更新根节点
    49. 					}
    50. 					//将其父节点指向的自身的指针置空
    51. 					else if (parent->_lchild == cur)
    52. 					{
    53. 						parent->_lchild = nullptr;
    54. 					}
    55. 					else
    56. 					{
    57. 						parent->_rchild = nullptr;
    58. 					}
    59. 					//释放节点空间
    60. 					delete cur;
    61. 					cur = nullptr;
    62. 				}
    63. 				else if (cur->_rchild == nullptr)//删除的节点右孩子为空,左孩子不为空
    64. 				{
    65. 					if (parent == cur)//删除的是根节点
    66. 					{
    67. 						_root = cur->_lchild;//更新根节点
    68. 					}
    69. 					//将删除节点的左孩子交给其父节点
    70. 					else if (parent->_lchild == cur)
    71. 					{
    72. 						parent->_lchild = cur->_lchild;
    73. 					}
    74. 					else
    75. 					{
    76. 						parent->_rchild = cur->_lchild;
    77. 					}
    78. 					//释放节点空间
    79. 					delete cur;
    80. 					cur = nullptr;
    81. 				}
    82. 				else if (cur->_lchild == nullptr)//删除的节点左孩子为空,右孩子不为空
    83. 				{
    84. 					if (parent == cur)//删除的是根节点
    85. 					{
    86. 						_root = cur->_rchild;//更新根节点
    87. 					}
    88. 					//将删除节点的右孩子交给其父节点
    89. 					else if (parent->_lchild == cur)
    90. 					{
    91. 						parent->_lchild = cur->_rchild;
    92. 					}
    93. 					else
    94. 					{
    95. 						parent->_rchild = cur->_rchild;
    96. 					}
    97. 					//释放节点空间
    98. 					delete cur;
    99. 					cur = nullptr;
    100. 				}
    101. 				else//删除的节点左右孩子都不为空,要找到删除节点的左子树的最大节点或右子树的最小节点可将其替换
    102. 				{
    103. 					//这里找要删除节点的左子树的最大节点（右子树的最小节点也可）
    104. 					Node* maxleft = cur->_lchild; // 记录左子树的最大节点
    105. 					Node* pmaxleft = cur;//记录左子树的最大节点的父节点
    106. 					while (maxleft->_rchild)//查找左子树的最大节点
    107. 					{
    108. 						pmaxleft = maxleft;
    109. 						maxleft = maxleft->_rchild;
    110. 					}
    111. 					//将找到的节点替换要删除的节点
    112. 					cur->_key = maxleft->_key;
    113. 					if (pmaxleft->_lchild == maxleft)
    114. 					{
    115. 						pmaxleft->_lchild = maxleft->_lchild;
    116. 					}
    117. 					else
    118. 					{
    119. 						pmaxleft->_rchild = maxleft->_lchild;
    120. 					}
    121. 					//释放节点空间
    122. 					delete maxleft;
    123. 					maxleft = nullptr;
    124. 				}
    125. 				return true;
    126. 			}
    127. 		}
    128. 		return false;//没找到要删除的节点
    129. 	}
    130. private:
    131. 	Node* _root = nullptr;//根节点
    132. };

    2.4.1 删除数据的非递归实现

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6. 	bool EraseR(const K& key)//递归删除数据
    7. 	{
    8. 		return _EraseR(_root, key);
    9. 	}
    10.  
    11. 	bool _EraseR(Node*& root, const K& key)
    12. 	{
    13. 		if (root == nullptr)
    14. 		{
    15. 			return false;
    16. 		}
    17. 		else if (root->_key < key)
    18. 		{
    19. 			_EraseR(root->_rchild, key);
    20. 		}
    21. 		else if (root->_key > key)
    22. 		{
    23. 			_EraseR(root->_lchild, key);
    24. 		}
    25. 		else
    26. 		{
    27. 			Node* del = root;
    28. 			if (root->_lchild == root->_rchild && root->_lchild == nullptr)//删除的节点为叶子节点
    29. 			{
    30. 				//释放节点空间
    31. 				delete root;
    32. 				//将其父节点指向的自身的指针置空
    33. 				root = nullptr;
    34. 			}
    35. 			else if (root->_rchild == nullptr)//删除的节点右孩子为空,左孩子不为空
    36. 			{
    37. 				//将删除节点的左孩子交给其父节点
    38. 				root = root->_lchild;
    39. 				//释放节点空间
    40. 				delete del;
    41. 				del = nullptr;
    42. 			}
    43. 			else if (root->_lchild == nullptr)//删除的节点左孩子为空,右孩子不为空
    44. 			{
    45. 				//将删除节点的右孩子交给其父节点
    46. 				root = root->_rchild;
    47. 				//释放节点空间
    48. 				delete del;
    49. 				del = nullptr;
    50. 			}
    51. 			else//删除的节点左右孩子都不为空,要找到删除节点的左子树的最大节点或右子树的最小节点将其替换
    52. 			{
    53. 				//这里找要删除节点的右子树的最小节点（左子树的最大节点也可）
    54. 				Node* minright = del->_rchild; // 记录右子树的最小节点
    55. 				while (minright->_lchild)//查找右子树的最小节点
    56. 				{
    57. 					minright = minright->_lchild;
    58. 				}
    59. 				root->_key = minright->_key;//将找到的节点替换要删除的节点
    60. 				return _EraseR(root->_rchild, root->_key);//继续递归删除其右子树中用来替换的节点
    61. 			}
    62. 			return true;
    63. 		}
    64. 	}
    65.  
    66. private:
    67. 	Node* _root = nullptr;//根节点
    68. };

    2.5 二叉搜索树的析构

    1. class BSTree 
    2. {
    3. 	typedef BSTreeNode Node;
    4.  
    5. public:
    6. 	~BSTree()//析构
    7. 	{
    8. 		Destory(_root);
    9. 	}
    10. 	void Destory(Node*& root)//销毁二叉搜索树
    11. 	{
    12. 		if (root == nullptr)
    13. 			return;
    14. 		Destory(root->_lchild);
    15. 		Destory(root->_rchild);
    16. 		delete root;
    17. 		root = nullptr;
    18. 	}
    19. private:
    20. 	Node* _root = nullptr;//根节点
    21. };

    2.6 二叉搜索树的拷贝构造

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5.  
    6. public:
    7.  
    8. 	BSTree(const BSTree& t)//拷贝构造
    9. 	{
    10. 		_root = Copy(t._root);
    11. 	}
    12.  
    13. 	Node* Copy(const Node* node)//拷贝
    14. 	{
    15. 		if (node == nullptr)
    16. 		{
    17. 			return nullptr;
    18. 		}
    19. 		Node* newnode = new Node(node->_key);
    20. 		newnode->_lchild = Copy(node->_lchild);
    21. 		newnode->_rchild = Copy(node->_rchild);
    22. 		return newnode;
    23. 	}
    24.  
    25. private:
    26. 	Node* _root = nullptr;//根节点
    27. };

    2.7 赋值重载

    1. template<class K>
    2. class BSTree 
    3. {
    4. 	typedef BSTreeNode Node;
    5. public:
    6.     BSTree& operator=(BSTree t)//赋值重载
    7. 	{
    8. 		std::swap(_root, t._root);
    9. 		return *this;
    10. 	}
    11. private:
    12. 	Node* _root = nullptr;//根节点
    13. };

    2.8 模拟实现二叉搜索树的全部代码

    1. #include
    2. using namespace std;
    3.  
    4. template<class K>
    5. struct BSTreeNode//节点
    6. {
    7. 	BSTreeNode* _lchild;
    8. 	BSTreeNode* _rchild;
    9. 	K _key;
    10.  
    11. 	BSTreeNode(const K& key)
    12. 		:_lchild(nullptr),
    13. 		_rchild(nullptr),
    14. 		_key(key)
    15. 	{}
    16. };
    17.  
    18. template<class K>
    19. class BSTree 
    20. {
    21. 	typedef BSTreeNode Node;
    22.  
    23. public:
    24. 	BSTree() = default;//强制生成默认拷贝函数
    25.  
    26. 	BSTree(const BSTree& t)//拷贝构造函数
    27. 	{
    28. 		_root = Copy(t._root);
    29. 	}
    30.  
    31. 	~BSTree()//析构
    32. 	{
    33. 		Destory(_root);
    34. 	}
    35.  
    36. 	bool Insert(const K& key)//插入数据
    37. 	{
    38. 		if (_root == nullptr)//如果根节点为空就直接插入
    39. 		{
    40. 			_root = new Node(key);
    41. 			_root->_key = key;
    42. 			return true;
    43. 		}
    44. 		Node* cur = _root;//使用cur遍历二叉树找到合适的插入位置
    45. 		Node* parent = cur;//记录cur的父节点
    46. 		while (cur)
    47. 		{
    48. 			parent = cur;
    49. 			if (key < cur->_key)
    50. 			{
    51. 				cur = cur->_lchild;
    52. 			}
    53. 			else if (key > cur->_key)
    54. 			{
    55. 				cur = cur->_rchild;
    56. 			}
    57. 			else
    58. 			{
    59. 				return false;//这里创建的二叉搜索树不允许出现值的冗余
    60. 			}
    61. 		}
    62. 		cur = new Node(key);//创建
    63. 		//将创建的节点链接到二叉树上
    64. 		if (key < parent->_key)
    65. 		{
    66. 			parent->_lchild = cur;
    67. 		}
    68. 		else
    69. 		{
    70. 			parent->_rchild = cur;
    71. 		}
    72. 		return true;
    73. 	}
    74.  
    75. 	bool InsertR(const K& key)//插入数据(递归)
    76. 	{
    77. 		return _InsertR(_root, key);
    78. 	}
    79.  
    80. 	void InOrder()//中序遍历
    81. 	{
    82. 		_InOrder(_root);
    83. 		cout << endl;
    84. 	}
    85.  
    86. 	bool Find(const K& key)//查找数据
    87. 	{
    88. 		Node* cur = _root;
    89. 		while (cur)
    90. 		{
    91. 			if (cur->_key < key)
    92. 			{
    93. 				cur = cur->_rchild;
    94. 			}
    95. 			else if (cur->_key > key)
    96. 			{
    97. 				cur = cur->_lchild;
    98. 			}
    99. 			else
    100. 			{
    101. 				return true;
    102. 			}
    103. 		}
    104. 		return false;
    105. 	}
    106.  
    107. 	bool Erase(const K& key)
    108. 	{
    109. 		Node* cur = _root;//使用cur遍历二叉树找到要删除元素的位置
    110. 		Node* parent = cur;//记录cur的父节点
    111. 		while (cur)//寻找需要删除的节点
    112. 		{
    113. 			if (cur->_key < key)
    114. 			{
    115. 				parent = cur;
    116. 				cur = cur->_rchild;
    117. 			}
    118. 			else if (cur->_key > key)
    119. 			{
    120. 				parent = cur;
    121. 				cur = cur->_lchild;
    122. 			}
    123. 			else//找到了,开始删除
    124. 			{
    125. 				if (cur->_lchild == cur->_rchild && cur->_lchild == nullptr)//删除的节点为叶子节点
    126. 				{
    127. 					if (parent == cur)//删除的是根节点
    128. 					{
    129. 						_root = nullptr;//更新根节点
    130. 					}
    131. 					//将其父节点指向的自身的指针置空
    132. 					else if (parent->_lchild == cur)
    133. 					{
    134. 						parent->_lchild = nullptr;
    135. 					}
    136. 					else
    137. 					{
    138. 						parent->_rchild = nullptr;
    139. 					}
    140. 					//释放节点空间
    141. 					delete cur;
    142. 					cur = nullptr;
    143. 				}
    144. 				else if (cur->_rchild == nullptr)//删除的节点右孩子为空,左孩子不为空
    145. 				{
    146. 					if (parent == cur)//删除的是根节点
    147. 					{
    148. 						_root = cur->_lchild;//更新根节点
    149. 					}
    150. 					//将删除节点的左孩子交给其父节点
    151. 					else if (parent->_lchild == cur)
    152. 					{
    153. 						parent->_lchild = cur->_lchild;
    154. 					}
    155. 					else
    156. 					{
    157. 						parent->_rchild = cur->_lchild;
    158. 					}
    159. 					//释放节点空间
    160. 					delete cur;
    161. 					cur = nullptr;
    162. 				}
    163. 				else if (cur->_lchild == nullptr)//删除的节点左孩子为空,右孩子不为空
    164. 				{
    165. 					if (parent == cur)//删除的是根节点
    166. 					{
    167. 						_root = cur->_rchild;//更新根节点
    168. 					}
    169. 					//将删除节点的右孩子交给其父节点
    170. 					else if (parent->_lchild == cur)
    171. 					{
    172. 						parent->_lchild = cur->_rchild;
    173. 					}
    174. 					else
    175. 					{
    176. 						parent->_rchild = cur->_rchild;
    177. 					}
    178. 					//释放节点空间
    179. 					delete cur;
    180. 					cur = nullptr;
    181. 				}
    182. 				else//删除的节点左右孩子都不为空,要找到删除节点的左子树的最大节点或右子树的最小节点可将其替换
    183. 				{
    184. 					//这里找要删除节点的左子树的最大节点（右子树的最小节点也可）
    185. 					Node* maxleft = cur->_lchild; // 记录左子树的最大节点
    186. 					Node* pmaxleft = cur;//记录左子树的最大节点的父节点
    187. 					while (maxleft->_rchild)//查找左子树的最大节点
    188. 					{
    189. 						pmaxleft = maxleft;
    190. 						maxleft = maxleft->_rchild;
    191. 					}
    192. 					//将找到的节点替换要删除的节点
    193. 					cur->_key = maxleft->_key;
    194. 					if (pmaxleft->_lchild == maxleft)
    195. 					{
    196. 						pmaxleft->_lchild = maxleft->_lchild;
    197. 					}
    198. 					else
    199. 					{
    200. 						pmaxleft->_rchild = maxleft->_lchild;
    201. 					}
    202. 					//释放节点空间
    203. 					delete maxleft;
    204. 					maxleft = nullptr;
    205. 				}
    206. 				return true;
    207. 			}
    208. 		}
    209. 		return false;//没找到要删除的节点
    210. 	}
    211.  
    212.  
    213. 	bool EraseR(const K& key)//递归删除数据
    214. 	{
    215. 		return _EraseR(_root, key);
    216. 	}
    217.  
    218. 	BSTree& operator=(BSTree t)//赋值重载
    219. 	{
    220. 		std::swap(_root, t._root);
    221. 		return *this;
    222. 	}
    223.  
    224. protected:
    225. 	Node* Copy(const Node* node)//拷贝
    226. 	{
    227. 		if (node == nullptr)
    228. 		{
    229. 			return nullptr;
    230. 		}
    231. 		Node* newnode = new Node(node->_key);
    232. 		newnode->_lchild = Copy(node->_lchild);
    233. 		newnode->_rchild = Copy(node->_rchild);
    234. 		return newnode;
    235. 	}
    236.  
    237. 	void Destory(Node*& root)//销毁二叉搜索树
    238. 	{
    239. 		if (root == nullptr)
    240. 			return;
    241. 		Destory(root->_lchild);
    242. 		Destory(root->_rchild);
    243. 		delete root;
    244. 		root = nullptr;
    245. 	}
    246.  
    247. 	bool _InsertR(Node*& root,const K& key)//这里使用指针的引用用来直接修改其父节点指针的指向
    248. 	{
    249. 		if (root == nullptr)
    250. 		{
    251. 			root = new Node(key);
    252. 			return true;
    253. 		}
    254. 		if (root->_key > key)
    255. 		{
    256. 			_InsertR(root->_lchild, key);
    257. 		}
    258. 		else if (root->_key < key)
    259. 		{
    260. 			_InsertR(root->_rchild, key);
    261. 		}
    262. 		else
    263. 		{
    264. 			return false;
    265. 		}
    266. 	}
    267.  
    268. 	void _InOrder(Node* root)
    269. 	{
    270. 		if (root == NULL)//如果是空树就直接结束
    271. 		{
    272. 			return;
    273. 		}
    274. 		_InOrder(root->_lchild);//先递归遍历其左子树
    275. 		cout << root->_key << " ";//再遍历其根节点
    276. 		_InOrder(root->_rchild);//最后递归遍历其右子树
    277. 	}
    278.  
    279. 	bool _EraseR(Node*& root, const K& key)
    280. 	{
    281. 		if (root == nullptr)
    282. 		{
    283. 			return false;
    284. 		}
    285. 		else if (root->_key < key)
    286. 		{
    287. 			_EraseR(root->_rchild, key);
    288. 		}
    289. 		else if (root->_key > key)
    290. 		{
    291. 			_EraseR(root->_lchild, key);
    292. 		}
    293. 		else
    294. 		{
    295. 			Node* del = root;
    296. 			if (root->_lchild == root->_rchild && root->_lchild == nullptr)//删除的节点为叶子节点
    297. 			{
    298. 				//释放节点空间
    299. 				delete root;
    300. 				//将其父节点指向的自身的指针置空
    301. 				root = nullptr;
    302. 			}
    303. 			else if (root->_rchild == nullptr)//删除的节点右孩子为空,左孩子不为空
    304. 			{
    305. 				//将删除节点的左孩子交给其父节点
    306. 				root = root->_lchild;
    307. 				//释放节点空间
    308. 				delete del;
    309. 				del = nullptr;
    310. 			}
    311. 			else if (root->_lchild == nullptr)//删除的节点左孩子为空,右孩子不为空
    312. 			{
    313. 				//将删除节点的右孩子交给其父节点
    314. 				root = root->_rchild;
    315. 				//释放节点空间
    316. 				delete del;
    317. 				del = nullptr;
    318. 			}
    319. 			else//删除的节点左右孩子都不为空,要找到删除节点的左子树的最大节点或右子树的最小节点将其替换
    320. 			{
    321. 				//这里找要删除节点的右子树的最小节点（左子树的最大节点也可）
    322. 				Node* minright = del->_rchild; // 记录右子树的最小节点
    323. 				while (minright->_lchild)//查找右子树的最小节点
    324. 				{
    325. 					minright = minright->_lchild;
    326. 				}
    327. 				root->_key = minright->_key;//将找到的节点替换要删除的节点
    328. 				return _EraseR(root->_rchild, root->_key);//继续递归删除其右子树中用来替换的节点
    329. 			}
    330. 			return true;
    331. 		}
    332. 	}
    333.  
    334. private:
    335. 	Node* _root = nullptr;//根节点
    336. };

    三、二叉搜索树的应用

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

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

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

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

    四、二叉搜索树的性能分析

    对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二 叉搜索树的深度的函数，即结点越深，则比较次数越多。

    但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

    所以最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：O(㏒⑵N)

    最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：O(N)

    那如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插 入关键码，二叉搜索树的性能都能达到最优？

    那么我们后面就要学习的AVL树和红黑树了。

    本期博客到这里就结束了，代码量较大，还请各位仔细分析呀

    我们下期见~

  • 相关阅读:
    C++中的extern “C”用法笔记
    Spring Cloud Stream绑定器架构解析与开发
    MongoDB基础学习
    电脑小白快来！这有电脑常见故障解决方法
    力扣解法汇总592-分数加减运算
    配置OSPF包文分析和验证
    PHP之内置web服务器
    MyBatis中有哪些注解呢？
    出现问题，你的pin不可用
    react路由基础
  • 原文地址：https://blog.csdn.net/m0_70811813/article/details/134398364