二叉搜索树

---

1、二叉树的概念

二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树)它或者是一棵空树，或者是具有下列性质的二叉树: 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树

二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构。中序遍历二叉排序树可得到一个关键字的有序序列，一个无序序列可以通过构造一棵二叉排序树变成一个有序序列，构造树的过程即为对无序序列进行排序的过程。每次插入的新的结点都是二叉排序树上新的叶子结点，在进行插入操作时，不必移动其它结点，只需改动某个结点的指针，由空变为非空即可。搜索,插入,删除的复杂度等于树高，O($lo{g}_{2}N$)

2、二叉搜索树的实现

2.1 结点的定义和框架

//结点的模板
template<class K>
struct BSTreeNode
{
	K _key;//存放数据
	BSTreeNode<K>* _left;//左孩子指针
	BSTreeNode<K>* _right;//右孩子指针

	//构造函数，左孩子和右孩子默认给空
	BSTreeNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K>
struct BSTree
{
	typedef BSTreeNode<K> Node;//重命名
private:
	Node* _root;
}

2.2 中序遍历

public:
	void InOrder()
	{
		_InOrede(_root);
		cout << endl;
	}

private:
	void _InOrede(Node* root)
	{
		if (root == nullptr)//为nullptr，则返回
			return;
		_InOrede(root->_left);//递归左
		cout << root->_key << " ";
		_InOrede(root->_right);//递归右
	}

2.3 搜索（迭代和递归）

public:
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)//如果key比当前结点(cur->_key)的值大，则key在右子树
				cur = cur->_right;
			else if (key < cur->_key)//如果key比当前结点(cur->_key)的值小，则key在左子树
				cur = cur->_left;
			else
				return root;//找到了，则返回true
		}
		return nullptr;//找不到，返回false
	}
	
	//给一个查找的接口，将实现放在private中
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}

private:
	Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)//走到nullptr了，则说明没有值为key的结点，返回nullptr
			return nullptr;
		if (key > root->_key)//如果key比当前结点(cur->_key)的值大,则递归右子树
			_FindR(root->_right, key);
		else if (key < root->_key)//如果key比当前结点(cur->_key)的值小,则递归左子树
			_FindR(root->_left, key);//找到了，返回值为key的结点
		return root;
	}

2.4 插入（迭代和递归）

public:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		else
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)//寻找插入的位置
			{
				if (key > cur->_key)//key比cur大，说明要插入到右子树
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)//key比cur小，说明要插入到左子树
				{
					parent = cur;
					cur = cur->_left;
				}
				else//如果要key已经存在，则不需要再插入，返回false
				{
					return false;
				}
			}
			if (key > parent->_key)//key比parent大，插在右边
				parent->_right = new Node(key);
			else//key比parent小，插在左边
				parent->_left = new Node(key);
		}
		return true;
	}
	
	//给一个插入的接口，实现放在private中
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

private:
	bool _InsertR(Node* &root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		} 
		if (key > root->_key)//key比当前结点的值大，则说明应该插入到右子树当中
			_InsertR(root->_right, key);
		else if (key < root->_key)//key比当前结点的值下，则说明应该插入到左子树当中
			_InsertR(root->_left, key);
		return false;//走到这里，则说明树中已经存在结点的值和key相等的情况，则不需要插入，返回false
	}

2.5 删除（迭代和递归）

public:
bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)//key比cur大，在右边
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)//key比cur小，在左边
			{
				parent = cur;
				cur = cur->_left;
			}
			else//找到了，然后进行删除
			{
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)//处理cur为根节点，parent为nullptr的情况
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)//cur是parent的右子树
							parent->_right = cur->_right;//parent的右连接cur的右
						else//cur是parent的左子树
							parent->_left = cur->_right;//parent的左连接cur的右
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)//处理cur为根节点，parent为nullptr的情况
					{
						_root = cur->_left;
					}
					else
					{

						if (parent->_right == cur)//cur是parent的右子树
							parent->_right = cur->_left;//parent的右连接cur的左
						else//cur是parent的左子树
							parent->_left = cur->_left;//parent的左连接cur的左
					}
					delete cur;
				}
				else//cur的左右都不为nullptr,左子树最右节点或者右子树的最左结点
				{
					Node* min = cur->_right;
					Node* minparent = cur;//也能处理min已经没有左子树，已经是最小结点的情况
					while (min->_left)//找最小
					{
						minparent = min;
						min = min->_left;
					}
					cur->_key = min->_key;//将min中的_key赋值给cur
					if (minparent->_left == min)
						minparent->_left = min->_right;//处理minparent的左结点是min的情况
					else
						minparent->_right = min->_right;//处理minparent的右结点是min的情况
					delete min;

				}
				return true;
			}
		}
		return false;//，如果走到这里，表示没有这个值
	}

	//给一个删除的接口，实现放在private中
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)//root为nullptr，则说明树中没有我们需要删除的值，返回false
			return false;
		if (key > root->_key)//递归右子树找key
			_EraseR(root->_right, key);
		else if (key < root->_key)//递归左子树找key
			_EraseR(root->_left, key);
		else//走到这一步，说明已经找到了，接下来就该进行删除操作
		{
			Node* del = root;//先将需要删除的结点保存起来
			if (root->_left == nullptr)//如果需要删除的结点的左子树为nullptr，则只需要将root的右子树的根节点赋值root，改变了解关系即可
			{
				root = root->_right;
				delete del;//释放del，放在内存泄漏
			}
			else if (root->_right == nullptr)//跟结点的左子树为nullptr的情况一样
			{
				root = root->_left;
				delete del;
			}
			else//左子树和右子树都不为nullptr
			{
				Node* min = root->_right;
				while (min->_left)
				{
					min = min->_left;
				}
				swap(min->_key, root->_key);//交换需要删除的值和右子树的最左结点的值
				//递归root的右子树，最终会走到if (root->_left == nullptr)或者else if (root->_right == nullptr)进行删除
				_EraseR(root->_right, key);
			}
		}
		return true;//走到这里，则说明删除结点成功
	}

迭代过程的图解(cur为我们需要删除的结点)：

cur的左子树为nullptr
第一种情况，parent == nullptr

第二种情况，parent->_right == cur

第三种情况，parent->_left == cur

cur的右子树为nullptr和左子树为nullptr情况一样，只是方向相反而已

cur的左子树和右子树都不为nullptr，有两种解决方案：将左子树最右节点或者右子树的最左结点赋值给cur，再删除最右结点或者最左结点
我们选择右子树的最左结点
第一种情况，minparent->_right == min

第二种情况，minparent->_left == min

3、二叉搜索树的应用

1.K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

• 以单词集合中的每个单词作为key，构建一棵二叉搜索树
• 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误

2.KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对
比如：实现一个简单的英汉词典dict，可以通过英文找到与其对应的中文，具体实现方式如下：

• <单词，中文含义>为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较Key
• 查询英文单词时，只需给出英文单词，就可快速找到与其对应的key

对于KV模型，我们只需要在模板中多添加一个参数，在其他的地方稍作修改即可

template<class K, class V>
struct BSTreeNode
{
	K _key;
	V _value;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

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


template<class K, class V>
struct BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	BSTree()
		:_root(nullptr)
	{}

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


	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return true;
		}
		else
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)//寻找插入的位置
			{
				if (key > cur->_key)//key比cur大，说明要插入到右子树
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)//key比cur小，说明要插入到左子树
				{
					parent = cur;
					cur = cur->_left;
				}
				else//如果要key已经存在，则不需要再插入，返回false
				{
					return false;
				}
			}
			if (key > parent->_key)//key比parent大，插在右边
				parent->_right = new Node(key, value);
			else//key比parent小，插在左边
				parent->_left = new Node(key, value);
		}
		return true;
	}


	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)//key比cur大，在右边
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)//key比cur小，在左边
			{
				parent = cur;
				cur = cur->_left;
			}
			else//找到了，然后进行删除
			{
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)//处理cur为根节点，parent为nullptr的情况
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)//cur是parent的右子树
							parent->_right = cur->_right;//parent的右连接cur的右
						else//cur是parent的左子树
							parent->_left = cur->_right;//parent的左连接cur的右
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)//处理cur为根节点，parent为nullptr的情况
					{
						_root = cur->_left;
					}
					else
					{

						if (parent->_right == cur)//cur是parent的右子树
							parent->_right = cur->_left;//parent的右连接cur的左
						else//cur是parent的左子树
							parent->_left = cur->_left;//parent的左连接cur的左
					}
					delete cur;
				}
				else//cur的左右都不为nullptr,左子树最右节点或者右子树的最左结点
				{
					Node* min = cur->_right;
					Node* minparent = cur;//也能处理min已经没有左子树，已经是最小结点的情况
					while (min->_left)//找最小
					{
						minparent = min;
						min = min->_left;
					}
					cur->_key = min->_key;//将min中的_key赋值给cur
					cur->_value = min->_value;

					if (minparent->_left == min)
						minparent->_left = min->_right;//处理minparent的左结点是min的情况
					else
						minparent->_right = min->_right;//处理minparent的右结点是min的情况
					delete min;

				}
				return true;
			}
		}
		return false;//，如果走到这里，表示没有这个值
	}


	void InOrder()
	{
		_InOrede(_root);
		cout << endl;
	}
private:

	void _InOrede(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrede(root->_left);//递归左
		cout << root->_key << ":" << root->_value << endl;
		_InOrede(root->_right);//递归右
	}
	Node* _root;
};

void test2()
{
	KV::BSTree<string, string> dict;
	dict.Insert("hello", "你好");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.InOrder();

}
int main()
{
	test2();
	return 0;
}

运行代码：

再举个栗子：
对于不存在的水果，就插入，存在了就统计次数

void test3()
{
	KV::BSTree<string, int> countTree;
	string arr[] = { "苹果", "李子", "苹果", "香蕉", "西瓜", "香蕉", "桃子", "桃子", "桃子", "西瓜" };
	for (auto& str : arr)
	{
		auto ret = countTree.Find(str);
		if (ret != nullptr)
			ret->_value++;
		else
			countTree.Insert(str, 1);
	}
	countTree.InOrder();
}
int main()
{
	test3();
	return 0;
}