二叉搜索树(Binary Search Tree)

1.二叉搜索树的概念

二叉搜索树又称为二叉排序树、二叉查找树，它或者是一棵空树，或者是具有以下性质的二叉树：1. 非空左子树的所有键值小于其根节点的键值；
2. 非空右子树的所有键值大于其根节点的键值；
3. 左右子树也分别为二叉搜索树。

二叉搜索树一般不支持key值冗余（不允许有重复的key值）；二叉搜索树的性质使搜索时非常方便高效，最多搜索高度次O(logN)（二叉树退化为O(N)，需要二叉搜索树平衡，使用AVL树或者红黑树）；二叉搜索树的中序遍历能够对key进行排序。

2.二叉搜索树的操作

2.1 二叉搜索树节点的创建

首先使用结构体+模板来创建节点，结构体中需要给出指向左子树、右子树的指针以及节点的值。代码如下：

//1、创建二叉搜索树的节点
template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;//指向左子树
	BSTreeNode<K>* _right;//指向右子树
	K _key;//节点的键值

	//构造函数
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

2.2 二叉搜索树的查找

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

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

//2、查找二叉树中是否有元素key
bool Find(const K& key)
{
    Node* cur = _root;
		
	while (cur)
	{
	    if (cur->_key > key)
		{
		    cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			cur = cur->_right;
		}
		else
		{
			return true;
		}
	}

	return false;
}

2.3 二叉搜索树的插入

插入的具体过程如下：

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

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

首先定义一个临时指针对二叉树进行遍历，该key的值比cur中的值大，就向cur的右子树中寻找，反之，向cur的左子树去寻找，直到叶子结点为止，如果与cur的值相同，则返回false（因为二叉搜索树中不允许有相同值的两个结点）。

//1.往二叉搜索树中插入一个元素，插入成功返回true，插入失败返回false
bool Insert(const K& key)
{
    //1、如果二叉树为空，则创建新节点，并将_root指向该节点
	if (_root == nullptr)
	{
	    _root = new Node(key);
		return true;
	}

	//2、二叉树不为空
	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);
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

	return true;
}

2.4 删除二叉搜索树中某个节点

删除二叉搜索树种的某个节点分为三种情况：

1、要删除的节点左子树为空；

2、要删除的节点右子树为空；

3、要删除的节点左右子树都不为空。

2.4.1 要删除的节点左子树为空，右子树不为空

1、若删除的是根节点，那么直接让根结点指向原根结点的右子树。

2、若删除的不是根节点，那么将要删除节点的父亲节点指向要删除节点的子树。分为两种情况：（1）要删除节点为其父亲节点的左子树；（2）要删除节点为其父亲节点的右子树。

2.4.2 要删除的节点右子树为空，左子树不为空

1、若删除的是根节点，那么直接让根结点指向原根结点的左子树。

2、若删除的不是根节点，那么将要删除节点的父亲节点指向要删除节点的子树。分为两种情况：（1）要删除节点为其父亲节点的左子树；（2）要删除节点为其父亲节点的右子树。

2.4.3 要删除的节点左、右子树都不为空

要删除的节点的左右子树均不为空，要考虑到该节点不能破坏二叉搜索树的性质。故不能直接删除该节点，利用替换法删除该节点。可以使用左子树的最大节点，或者右子树的最小节点来替换要删除的节点，并删除该最大节点或最小节点。假设使用要删除节点的右子树最小节点来替换该要删除节点，分两种情况：1、该最小节点为其父亲节点左孩子节点；2、该最小节点为其父亲节点的右孩子节点。

2.4.4 具体实现代码

//3、删除二叉搜索树中某个节点
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
		{
			//此时找到了要删除的节点，分为3种情况：
			//1.要删除的节点左子树为空；
			//2.要删除的节点右子树为空；
			//3.要删除的节点左右子树都不为空。
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_right == cur)
					    parent->_right = cur->_right;
					else
						parent->_left = cur->_right;
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_right == cur)
						parent->_right = cur->_left;
					else
						parent->_left = cur->_left;
				}
				delete cur;
			}
			else
			{
			//此时要删除的节点的左右子树均不为空，故不能直接删除该节点，利用替换法删除该节点；
			//可以使用左子树的最大节点，或者右子树的最小节点来替换要删除的节点，并删除该最大节点                
            //或最小节点
					
			    //使用右子树的最小节点来替换要删除的节点
				Node* rightMinParent = cur;
				Node* rightMin = cur->_right;
				while (rightMin->_left)
				{
					rightMinParent = rightMin;
					rightMin = rightMin->_left;
				}

				//用右子树的最小节点来替换要删除的节点
				cur->_key = rightMin->_key;

				//转换成删除rightMin节点（rightMin是左为空，父亲指向他的右）
				if (rightMin == rightMinParent->_left)
					rightMinParent->_left = rightMin->_right;
				else
					rightMinParent->_right = rightMin->_right;

				delete rightMin;
			}
				
			return true;
		}
	}
	return false;
}

2.5 中序遍历

//4、中序遍历
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;

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

//为什么要写一个子函数，进而调用该子函数呢？
//因为如果直接使用InOrder()函数传入_root，由于_root是类BSTree私有的，外界获取不到，故无法在类外
//直接将_root传入。
//要想在类外获取_root，需要再写个GetRoot()函数。即获取类的私有变量，故使用自函数的方式来调用。
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

3.二叉搜索树的应用-KV模型

代码如下：

#include<iostream>
using namespace std;

//二叉搜索树的K-Value模型
//1、创建二叉搜索树的节点
template<class K, class V>
struct BSTreeNode
{
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	K _key;
	V _value;

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


template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	//1、往搜索二叉树中插入一个元素，插入成功返回true，插入失败返回false
	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;
	}

	//2、查找二叉树中是否有元素key
	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;
	}

	//3、删除某个节点
	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
			{
				//找到了，开始删除
				//1、左为空
				//2、右为空
				//3、左右都不为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_right;
						else
							parent->_left = cur->_right;
					}

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

					delete cur;
				}
				else
				{
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					//用右子树的最小节点替换要删除的节点
					cur->_key = rightMin->_key;

					//转换成删除rightMin（rightMin是左为空，父亲指向他的右）
					if (rightMin == rightMinParent->_left)
						rightMinParent->_left = rightMin->_right;
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}


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

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

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	Node* _root = nullptr;
};


void TestBSTree_1()
{
	BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("insert", "插入");

	string str;
	while (cin >> str)
	{
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

void TestBSTree_2()
{
	string strArr[] = { "西瓜","苹果", "西瓜", "西瓜", "苹果", "西瓜", "香蕉", "西瓜", "樱桃", "西瓜", "西瓜", };
	BSTree<string, int>countTree;
	for (auto str : strArr)
	{
		BSTreeNode<string, int>* ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

int main()
{
	//TestBSTree_1();
	TestBSTree_2();
	return 0;
}

3.1 英汉互译

当我们输入相应的英文时，就会出现英文所对应的汉语，这就是KV模型带来的作用。我们将英文和汉语都存放在节点中，以key为关键码。每个key都对应着一个value，我们去寻找的时候只需要对比key就行了。

3.2 统计水果个数

遍历数组中的水果，当遇到相同的水果时只在节点的_value上进行++操作，用来计算每个水果出现的次数，最后中序遍历输出。

完整代码可以参考：二叉搜索树的实现、二叉搜索树的应用-KV模型