二叉搜索树

已于 2022-05-17 09:26:15 修改
阅读量562 收藏 5
点赞数 17
分类专栏： C++知识 数据结构与算法 文章标签： 数据结构 二叉搜索树 KV模型 二叉搜索树的应用 C++
于 2022-05-16 15:46:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56044032/article/details/124198134
版权

文章目录

1、二叉树的概念

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

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

在这里插入图片描述

你好，冯同学
关注
  • 17
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
【二叉搜索树】二叉搜索树的用法以及实现
m0_68617301的博客
04-28 1114
二叉搜索树的用法以及实现
二叉搜索树（BST）
几番离愁的博客
04-02 658
1 二叉搜索树（BST） 1.1 定义 二叉搜索树是指二叉树中各节点（或对应的关键码）的值支持大小比较，且左子树上所有结点的值均小于它的根结点的值，右子树上所有结点的值均大于它的根结点的值的树。 1.2 顺序性 二叉搜索树中序遍历可转换成线性序列，该序列的节点严格按照其大小次序排列，可得结论：二叉搜索树当且仅当其中中序遍历单调非降 1.3 查找 1.3-1 算法 二叉搜索树的查找算法，采用了...
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点： 1. 节点的左...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
Python实现二叉搜索树
09-21
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，其特性在于每个节点的左子树上的所有节点的值均小于该节点的值，而右子树上所有节点的值均大于该节点的值。这种结构使得二叉搜索树在搜索、插入...
二叉搜索树_二叉搜索树_源码
10-04
在给定的“二叉搜索树_二叉搜索树_源码”压缩包中，包含了一个名为“二叉搜索树.c”的源代码文件和一个编译后的可执行文件“二叉搜索树.exe”。源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本...
C#创建二叉搜索树的方法
09-03
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树结构，它的每个节点都包含一个键值（key），并且满足以下性质： 1. **左子树性质**：对于节点的左子树，所有节点的键值必须小于该节点的键值。 2. **右子...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
二叉搜索树（二叉查找树）
d65793577的专栏
05-16 945
二叉搜索树基本操作简介，附带C#实现代码
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值