C++_进阶：二叉搜索树

1. 二叉搜索树是什么

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

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

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

2. 二叉搜索树的基本操作

二叉搜索树的查找:

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

二叉搜索树的插入:
3. 当树为空(root == nullptr )时，则直接新增节点，赋值给root指针。
4. 当**树不为空(root != nullptr )**时，按二叉搜索树性质查找插入位置，插入新节点

二叉搜索树的删除:
先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面三种情况：

像1,2 情况，直接删除即可，删除后依然能维持二叉搜索树的结构。

情况3比前两种复杂一点，需要在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除。



二叉搜索树的遍历:
二叉搜索树的中序遍历，是一串递增序列。

3. 二叉搜索树的实现

先要实现一个Binary Search Tree节点类模板

template<class T>
class BSTreeNode
{
public:
	BSTreeNode(const T&key)
		:_val(key),
		left(nullptr),
		right(nullptr)
	{

	}
	//成员即 值 ， 左子树，右子树
	T _val;
	BSTreeNode* left;
	BSTreeNode* right;
};

再实现二叉搜索树本体

template<class T>
class BSTree
{
	typedef BSTreeNode<T> Node;
public:
	bool find(const T& key)
	{
		Node* cur = root;
		while (cur)
		{
			if (cur->_val > key)
			{
				cur = cur->left;
			}
			else if (cur->_val < key)
			{
				cur = cur->right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Insert(const T& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = root;
		while (cur)
		{
			if (cur->_val > key)
			{
				parent = cur;
				cur = cur->left;
			}
			else if (cur->_val < key)
			{
				parent = cur;
				cur = cur->right;
			}
			else
			{
				return false;
			}
		}
		if (parent->_val < key)
		{
			parent->right = new Node(key);
		}
		else
		{
			parent->left = new Node(key);
		}
		return true;
	}

	bool erase(const T& key)
	{
		Node* parent = nullptr;
		Node* cur = root;
		while (cur)
		{
			if (cur->_val > key)
			{
				parent = cur;
				cur = cur->left;
			}
			else if (cur->_val < key)
			{
				parent = cur;
				cur = cur->right;
			}
			else
			{
				//0-1孩子的情况
				if (cur->left == nullptr)
				{

					if (parent == nullptr)
					{
						root = cur->right;
					}
					else
					{
						if (cur == parent->left)
						{
							parent->left = cur->right;
						}
						else
						{
							parent->right = cur->right;
						}
					}
					
					delete cur;
					return true;
				}
				else if(cur->right== nullptr)
				{

					if (parent == nullptr)
					{
						root = cur->left;
					}
					else
					{
						if (cur == parent->left)
						{
							parent->left = cur->left;
						}
						else
						{
							parent->right = cur->left;
						}
					}
					
					delete cur;
					return true;
				}
				else
				{

					Node* rightMin = cur->right;
					Node* rightMinP = cur;

					while (rightMin->left)
					{
						rightMinP = rightMin;
						rightMin = rightMin->left;
					}
					
					cur->_val = rightMin->_val;

					if (rightMinP->left == rightMin)
					{
						cur->left = rightMin->right;
					}
					else
					{
						rightMinP->right = rightMin->right;
					}

					delete rightMin;
					return true;
				}
			}
		}

		return false;
	}
private:
	Node* root = nullptr;
};

4 二叉搜索树的应用

二叉搜索树一般有两种模型，一种为K模型，另一种为KV模型。

• K模型：K模型即只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，上文实现的都为K模型。
• KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。按照二叉搜索树规则用于调整的值依然是key，但每一个节点除了key多了个value作为这个节点解出的值。

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

//KV模型的二叉搜索树
template<class K, class V>
	struct BSTNode
	{
		// pair<K, V> _kv;
		K _key;
		V _value;
		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;

		BSTNode(const K& key, const V& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTNode<K, V> Node;
	public:
		BSTree() = default;

		BSTree(const BSTree<K, V>& t)
		{
			_root = Copy(t._root);
		}

		~BSTree()
		{
			Destroy(_root);
			_root = nullptr;
		}

		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key, value);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return cur;
				}
			}

			return nullptr;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					// 删除
					// 0-1个孩子的情况
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_right;
							else
								parent->_right = cur->_right;
						}

						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}

						delete cur;
						return true;
					}
					else
					{
						// 2个孩子的情况
						// 右子树的最小节点作为替代节点
						Node* rightMinP = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinP = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMinP->_left == rightMin)
							rightMinP->_left = rightMin->_right;
						else
							rightMinP->_right = rightMin->_right;

						delete rightMin;
						return true;
					}
				}
			}

			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}

		void Destroy(Node* root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);

			return newRoot;
		}

	private:
		Node* _root = nullptr;
	};

5 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

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

最优情况下，二叉搜索树为完全二叉树(或接近完全二叉树)，其平均比较次为O(logN)
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为 O(N)。

本文就到这里，感谢你看到这里❤️❤️！ 我知道一些人看文章喜欢静静看，不评论🤔，但是他会点赞😍，这样的人，帅气低调有内涵😎，美丽大方很优雅😊，明人不说暗话，要你手上的一个点赞😘！