二叉搜索树


1、二叉树的概念

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

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

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;
}

在这里插入图片描述

  • 17
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
评论 10
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值