搜索二叉树

最新推荐文章于 2024-07-02 13:47:27 发布

-Taco-

最新推荐文章于 2024-07-02 13:47:27 发布

阅读量326

点赞数 2

分类专栏： C++高阶数据结构 C++进阶文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/qq_52642334/article/details/128800980

版权

C++进阶同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

C++高阶数据结构

2 篇文章 0 订阅

订阅专栏

二叉搜索树

二叉搜索树概念

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

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

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

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

之前我们找数暴力查找，例如在顺序表里面查找最多得查找表长个。但是如果放在搜索二叉树里面，搜索二叉树只找n*logn也就是树高度次数。

二叉树先构建节点

template<class K>
struct BinarySearchNode
{
	BinarySearchNode(const K&key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}

	BinarySearchNode* _left;
	BinarySearchNode* _right;
	K _key;
};

之后节点构建之后再写树的结构

template<class K>
class BinarySearchTree
{
	typedef BinarySearchNode<K> Node;
	
private:
	Node* _root=nullptr;
};

先写二叉树的插入：

bool insert(const K& key)
	{
		if(_root == nullptr)
		{
			_root = new Node(key);//new 要调用node的构造函数
			return true;
		}
		Node* parent = nullptr;//只要是链式结构都得把它的前后链接起来
		//插入得找位置
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;//cur的先走，随后parent=cur，之后等到cur到尾部就结束，恰巧parent在上面
				//刚好链接
				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;

	}

二叉搜索树的查找

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

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

bool FindKey(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 true;
			}
		}
		return false;
	}

删除

有以下三种情况，但是第一二种情况可以归为一类；

下面开始写：

对称的如果cur的右边是空也是这种情况

所以代码的第一种情况应该这样写：

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 == nullptr)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				else if (cur->_right == nullptr)
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
			}
		}
		return false;
	}

但是如果我们干掉的是根节点的话，这时候根节点的parent是空，cur是根这种情况。

这时候如果不解决，下面的parent就变成了空指针解引用，会直接报错。

思路：我们只需要更新root就行，让删除根节点，让root等于cur的右边即可

if (cur->_left == nullptr)//左为空
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
				
				}
				else if (cur->_right == nullptr)//右为空
				{
					if (_root = cur)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
				
				}

处理完上面这两种情况就剩余了左右子树都有的情况了：

处理办法如下：

else//左右都不是空
				{
					//替换法删除（可以用左子树的最大值替换，也可以用右子树的最小值计算）
					//这里我们采取右子树的最小值
					Node* Min = cur->_right;
					Node* minParent = cur;//这里不能给空给空如果删除的是最上面的根就会出现下面
					//minParent空指针的问题；
					while (Min->_left)
					{
						minParent = Min;
						Min = Min->_left;
					}

					swap(cur->_key, Min->_key);
					//minParent->_left = Min->_right;
					if (minParent->_left == Min)
					{
						minParent->_left = Min->_right;
					}
					else
					{
						minParent->_right = Min->_right;
					}
					delete Min;

				}

搜索二叉树在当前这个模型不支持修改。

下面就递归的完整代码

template<class K>
struct BinarySearchNode
{
	BinarySearchNode(const K&key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}

	BinarySearchNode* _left;
	BinarySearchNode* _right;
	K _key;
};
template<class K>
class BinarySearchTree
{
	typedef BinarySearchNode<K> Node;
public:
	bool insert(const K& key)
	{
		if(_root == nullptr)
		{
			_root = new Node(key);//new 要调用node的构造函数
			return true;
		}
		Node* parent = nullptr;//只要是链式结构都得把它的前后链接起来
		//插入得找位置
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;//cur的先走，随后parent=cur，之后等到cur到尾部就结束，恰巧parent在上面
				//刚好链接
				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;

	}

	void Inorder()//这样嵌套是因为递归必须得传一个参数，但是这里的参数是this调用的，出了类this不能出现
		//想要空参调用，有三种处理方法，一种是把下面的test函数变成类的友元，另外一种是写一个接口getroot
		//第三种就写这种加一个函数封装一下；
	{
		_Inorder(_root);
		cout << endl;
	}
	bool FindKey(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 true;
			}
		}
		return false;
	}

	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 (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					cur = nullptr;
				
				}
				else if (cur->_right == nullptr)//右为空
				{
					if (_root == cur)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					cur = nullptr;
				
				}
				else//左右都不是空
				{
					//替换法删除（可以用左子树的最大值替换，也可以用右子树的最小值计算）
					//这里我们采取右子树的最小值
					Node* Min = cur->_right;
					Node* minParent = cur;//这里不能给空给空如果删除的是最上面的根就会出现下面
					//minParent空指针的问题；
					while (Min->_left)
					{
						minParent = Min;
						Min = Min->_left;
					}

					swap(cur->_key, Min->_key);
					//minParent->_left = Min->_right;
					if (minParent->_left == Min)
					{
						minParent->_left = Min->_right;
					}
					else
					{
						minParent->_right = Min->_right;
					}
					delete Min;

				}

				return true;
			}
		}
		return false;
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
		
	}
private:
	Node* _root=nullptr;
};

直至删成空树我们发现我们的结构依然成立。上面我们采用了非递归（循环）方法来写，现在我们采用递归的方法来写。

递归在前面二叉树便利有详细的讲解：

这里我们直接写他的find，跟之前一样，保证它的封装性在我们在封装一层：

find：

	bool FindR(const K&key)
	{
		return _FindR(_root, key);
	}
private:

	bool _FindR(Node*root,const K&key)
	{
		//比这个值大就去它的右子树，反之去它的左子树；
		if (root == nullptr)
		{
			return false;
		}

		if (root->_key < key)
		{
			return _FindR(_root->_right,key);
		}
		else if (root->_key > key)
		{
			return _FindR(_root->_left,key);
		}
		else
		{
			return true;
		}
	}

查找次数是树的高度

下面我们写插入：

bool _InsertR(Node*&root,const K& key)
	{
		//插入比它大就往右走，比它小就往左走，当root走到null的时候就是实际可以插入的时候
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			//相等就不让插入
			return false;
		}
	}

删除的话还是跟之前循环遍历的情况一样：

总共分为三种情况；

左右分别为0分析如下：

代码：

bool _EraseR(Node*&root,const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			//相等了就开始删除：
			//删除还是之前的三种情况：
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{

			}

		}

到了两个结点的情况：

else
			{
				//找右树的最左节点替换删除
				Node* min = root->_right;
				while (min->_left)
				{
					min = min->_left;
				}
				swap(root->_key, min->_key);
				//return EraseR(key);
				return _EraseR(root->_right, key);
			}

			delete del;
			return true;

解决拷贝的问题：

搜索二叉树查找的最坏的情况下是N（如果是有序的树--单支树）

理想状态下：如果这颗树是满二叉树，或者完全二叉树这种才能是logN

改进的树—-平衡树（1.AVL树，2.红黑树）

下面介绍两个模型：

Key的搜索模型，判断关键字在不在

场景1：检查单词拼写是否正确，把词库的单词全部插入到二叉树里面，去搜索比较，对就判断是正确的;

Key/Value模型--通过key去找value

场景1：简单的中英互译程序(通过一个值去找另外一个）

完整的key模型代码：

namespace Key
{
	template<class K>
	struct BinarySearchNode
	{
		BinarySearchNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}

		BinarySearchNode* _left;
		BinarySearchNode* _right;
		K _key;
	};
	template<class K>
	class BinarySearchTree
	{
		typedef BinarySearchNode<K> Node;
	public:
		bool insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Node(key);//new 要调用node的构造函数
				return true;
			}
			Node* parent = nullptr;//只要是链式结构都得把它的前后链接起来
			//插入得找位置
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;//cur的先走，随后parent=cur，之后等到cur到尾部就结束，恰巧parent在上面
					//刚好链接
					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;

		}

		void Inorder()//这样嵌套是因为递归必须得传一个参数，但是这里的参数是this调用的，出了类this不能出现
			//想要空参调用，有三种处理方法，一种是把下面的test函数变成类的友元，另外一种是写一个接口getroot
			//第三种就写这种加一个函数封装一下；
		{
			_Inorder(_root);
			cout << endl;
		}
		bool FindKey(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 true;
				}
			}
			return false;
		}

		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 (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
						cur = nullptr;

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

					}
					else//左右都不是空
					{
						//替换法删除（可以用左子树的最大值替换，也可以用右子树的最小值计算）
						//这里我们采取右子树的最小值
						Node* Min = cur->_right;
						Node* minParent = cur;//这里不能给空给空如果删除的是最上面的根就会出现下面
						//minParent空指针的问题；
						while (Min->_left)
						{
							minParent = Min;
							Min = Min->_left;
						}

						swap(cur->_key, Min->_key);
						//minParent->_left = Min->_right;
						if (minParent->_left == Min)
						{
							minParent->_left = Min->_right;
						}
						else
						{
							minParent->_right = Min->_right;
						}
						delete Min;

					}

					return true;
				}
			}
			return false;
		}

		/*******************************************************************************************/

			//递归写法：
		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}
		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}
		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

		~BinarySearchTree()
		{
			_Destory(_root);
		}
		BinarySearchTree()
		{

		}
		//或者这样写：
		//BinarySearchTree() = default;//强制编译器生成默认的构造

		//拷贝构造怎么写？(前序遍历，遇见一个节点copy一个节点)(前序遍历：根，左，右)
		BinarySearchTree(const BinarySearchTree<K>& t)
		{
			_root = _Copy(t._root);
		}
		//拷贝构造也是构造，自己写了，编译器就不会有构造函数了，上面还得写一个空参的构造函数


		//t2=t1;
		BinarySearchTree<K>& operator=(BinarySearchTree<K>t)//t就是t1的拷贝
		{

			swap(_root, t._root);//t就是t2想要的也就是this->_root；
			return *this;
		}



	private:
		/*******************************************************************************************/


		Node* _Copy(Node* root)//左右子树分别递归copy
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			Node* copyRoot = new Node(root->_key);//copy结点跟你有一样的值即可
			copyRoot->_left = _Copy(root->_left);
			copyRoot->_right = _Copy(root->_right);
			return copyRoot;
			//遇见根拷贝根遇见左子树递归拷贝左子树
		}

		void _Destory(Node*& root)
		{
			if (_root == nullptr)
			{
				return;
			}
			_Destory(_root->_left);
			_Destory(_root->_right);
			delete root;
			root = nullptr;
		}
		bool _FindR(Node* root, const K& key)
		{
			//比这个值大就去它的右子树，反之去它的左子树；
			if (root == nullptr)
			{
				return false;
			}

			if (root->_key < key)
			{
				return _FindR(_root->_right, key);
			}
			else if (root->_key > key)
			{
				return _FindR(_root->_left, key);
			}
			else
			{
				return true;
			}
		}
		bool _InsertR(Node*& root, const K& key)
		{
			//插入比它大就往右走，比它小就往左走，当root走到null的时候就是实际可以插入的时候
			if (root == nullptr)
			{
				root = new Node(key);
				return true;
			}

			if (root->_key < key)
			{
				return _InsertR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _InsertR(root->_left, key);
			}
			else
			{
				//相等就不让插入
				return false;
			}
		}
		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				return false;
			}
			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else//这时候遇见有左右子树的情况
			{
				//相等了就开始删除：
				//删除还是之前的三种情况：
				Node* del = root;
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					//找右树的最左节点替换删除
					Node* min = root->_right;
					while (min->_left)
					{
						min = min->_left;
					}
					swap(root->_key, min->_key);
					//return EraseR(key);
					return _EraseR(root->_right, key);
				}

				delete del;
				return true;

			}
		}
		/********************************************************************************************/
		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);

		}



	private:
		Node* _root = nullptr;
	};

	void TestBSTree1()
	{
		BinarySearchTree<int> b1;
		int a[] = { 8,3,1,10,6,4,7,14,13 };//这里如果传入多个相同值会被天然去重；
		for (auto e : a)
		{
			b1.insert(e);
		}
		b1.Inorder();
		for (auto e : a)
		{
			b1.Erase(e);
			b1.Inorder();
		}

	}
	void TestBSTree2()
	{
		BinarySearchTree<int> b1;
		int a[] = { 8,3,1,10,6,4,7,14,13 };//这里如果传入多个相同值会被天然去重；
		for (auto e : a)
		{
			b1.InsertR(e);
		}
		b1.Inorder();
		for (auto e : a)
		{
			b1.EraseR(e);
			b1.Inorder();
		}
	}
	void TestBSTree3()
	{
		BinarySearchTree<int>b1;
		int a[] = { 8,3,1,10,6,4,7,14,13 };
		for (auto e : a)
		{
			b1.InsertR(e);
		}
		BinarySearchTree<int> copy = b1;//没写析构所以拷贝不会崩溃


		copy.Inorder();
		b1.Inorder();



	}

}

完整的keyValue模型：

#include<string>
namespace KeyValue
{
	template<class K,class V>
	struct BinarySearchNode
	{
		BinarySearchNode(const K& key,const V&value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			,_value(value)
		{}

		BinarySearchNode<K,V>* _left;
		BinarySearchNode<K,V>* _right;
		K _key;
		V _value;//找到K就找到Value了
	};
	template<class K,class V>
	class BinarySearchTree
	{
		typedef BinarySearchNode<K,V> Node;
	public:
		bool insert(const K& key,const V&value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,value);//new 要调用node的构造函数
				return true;
			}
			Node* parent = nullptr;//只要是链式结构都得把它的前后链接起来
			//插入得找位置
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;//cur的先走，随后parent=cur，之后等到cur到尾部就结束，恰巧parent在上面
					//刚好链接
					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;

		}

		void Inorder()//这样嵌套是因为递归必须得传一个参数，但是这里的参数是this调用的，出了类this不能出现
			//想要空参调用，有三种处理方法，一种是把下面的test函数变成类的友元，另外一种是写一个接口getroot
			//第三种就写这种加一个函数封装一下；
		{
			_Inorder(_root);
			cout << endl;
		}
		Node* FindKey(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//找到了（开始删除）
				{
					//1.左为空
					//2.右为空
					//3.左右都不为空
					if (cur->_left == nullptr)//左为空
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
						cur = nullptr;

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

					}
					else//左右都不是空
					{
						//替换法删除（可以用左子树的最大值替换，也可以用右子树的最小值计算）
						//这里我们采取右子树的最小值
						Node* Min = cur->_right;
						Node* minParent = cur;//这里不能给空给空如果删除的是最上面的根就会出现下面
						//minParent空指针的问题；
						while (Min->_left)
						{
							minParent = Min;
							Min = Min->_left;
						}

						swap(cur->_key, Min->_key);
						//minParent->_left = Min->_right;
						if (minParent->_left == Min)
						{
							minParent->_left = Min->_right;
						}
						else
						{
							minParent->_right = Min->_right;
						}
						delete Min;

					}

					return true;
				}
			}
			return false;
		}

		
	private:
		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			cout << root->_key << ": " << root->_value << endl;
			_Inorder(root->_right);

		}
	private:
		Node* _root = nullptr;
	};
	void TestBinarySearchTest01()//词库搜索单词
	{
		BinarySearchTree<string, string> bs1;
		bs1.insert("sort", "排序");
		bs1.insert("right", "右边");
		bs1.insert("left", "左边");
		bs1.insert("string", "字符");
		bs1.insert("insert", "插入");//按照字符串的Asscii码值比较


		string str;
		while (cin >> str)
		{
			BinarySearchNode<string, string>* ret = bs1.FindKey(str);
			if (ret)
			{
				cout << ":" << ret->_value << endl;
			}
			else
			{
				cout << "->无此单词" << endl;
			}
		}
	}

	void TestBinarySearchTest02()//计数器
	{
		string arr[] = {"苹果","苹果" ,"香蕉" ,"草莓" ,"香蕉" ,"苹果" ,"苹果" ,"苹果" };
		BinarySearchTree<string, int> countTree;
		for (auto &str : arr)
		{
			BinarySearchNode<string, int>* ret = countTree.FindKey(str);
			if (ret)
			{
				ret->_value++;
			}
			else
			{
				countTree.insert(str, 1);
			}

		}
		countTree.Inorder();
	}
}