C++ 搜索二叉树（BST）模拟实现与应用

已于 2022-07-27 20:41:25 修改
阅读量405 收藏 2
点赞数
分类专栏： C++ 文章标签： 大数据
于 2022-07-26 22:22:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54831038/article/details/125813091
版权

目录

 (一）搜索二叉树 分析

1.结构：

2. 性能分析：

2.1BST与二分查找：

2.2树的平衡性将影响BST的性能。

（二）搜索二叉树实现

1.非递归实现

1.1查找

1.2插入

1.3定点删减

1.4 中序遍历（输出排序）

2.递归实现

2.1 递归与非递归版本对比

2.2  关键点分析

2.3代码实现

（三）二叉搜索树应用

1.场景一：用于排序《key模型》

2.场景二：用于搜索《key--value模型》

（四）源码分享

1.二叉搜索树非递归版本

2.key-value模型

                                      如有错误请多多指正，谢谢观看！

 (一）搜索二叉树 分析

1.结构：

  •  搜索二叉树主要功能有：搜索，增删，排序（中序遍历）。
  •  搜索二叉树的存储特点：在二叉树的基础上，左节点的键总是小于父节点的键，右节点的键总是大于父节点的键。在深层意义上，我们存储的数据需要有一个键（以此键作为标准来排序）。
  • 搜索二叉树中nullptr也被看成一个节点，这一点在递归中有很大妙用。
  • 父子节点的继承关系：我们假设 3为父节点，删除了3，父节点的位置将要由它的子节点继承，但这不改变子节点与它下一代节点的继承方式，问题的关键：“到底是左孩子节点还是右孩子节点顶替了父节点3"。这是插入和删除节点的时候我们最关心的问题。多继承问题是复杂的 ，所以我们将其转化为单继承问题解决，即”左/右孩子顶替了父节点“两种情况讨论。其他情况也划归成这两种情况。

2. 性能分析：

2.1BST与二分查找：

      谈起二分查找，在排序中算是很优秀的搜索算法，但是二分查找的条件要求存储数据必须是有序的数组/链表，然而对于一批维护的数据需要伴随着频繁的增删改查，以及排序算法多次调用带来的代价也就大了起来，随之程序的效率就会大大下降。而BST更像二分查找的存储升级版，可以有序的增删数据。

      相比之下，BST的存储和搜索就很均衡。BST在搜索中表现得也很好，每向下移动一个深度，就消除大约50%的潜在节点（接近O(log n)）。比如我们要找到2，我们就可以从根（5）开始，向左移动，意味着我们立刻消除了4个可能的节点。继续向1移动，我们又消除了一个可能的节点。然后在1的右面我们找到了节点，只通过了3步实现了的节点。

2.2树的平衡性将影响BST的性能。

 这个例子就很极端，当树不是最优或不平衡时候，BST的搜索性变差，O(n)可能成为最坏的情况。所以根据键值选取合适的根节点，调整存储顺序是很重要的因素。

（二）搜索二叉树实现

1.非递归实现

1.1查找

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

1.2插入

	bool Insert(const K& key)
	{
        //空树直接插入
		if (_root == nullptr)
		{
			_root = new Node(key);
			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);
        //插入：判断待插入节点的精确位置
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

1.3定点删除

	bool  Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到了，开始删除
			{
                //1.左为空或者右为空，把另一个孩子交给父亲管理，删除自己

				if (cur->_left == nullptr) //待删除节点左孩子为空
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{   
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else {
							parent->_right = 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;
						}
					}
				}
				else //2.左右孩子都不为空
				{
					//找到右树的最小节点去替代删除
					Node* minRightParent = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						minRightParent = minRight;
						minRight = minRight->_left;
					}
					cur->_key = minRight->_key;
                    //将右孩子交给父节点管理
					if (minRight == minRightParent->_left)
					{
						minRightParent->_left = minRight->_right;
					}
					else
					{
						minRightParent->_right = minRight->_right;
					}
					delete minRight;
					return true;
				}
			}
		}
		return false;
	}

1.4 中序遍历（输出排序）

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
    void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

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

2.递归实现

2.1 递归与非递归版本对比

1.一般工程中不建议使用非递归版本，额外开销很大。

2.非递归版本和递归版本间可以相互转化。

3.递归关注状态的分析。

2.2  关键点分析

递归的特点：一个子过程结束后自动链接下一个子过程。可以回溯到上一个节点，也可以传递到下一个节点。

   当前    _root节点A         子过程进行中
   接下来  _root->right节点B  子过程未进行  可以调用节点A,B,C
   接下来  _root->right节点C  子过程未进行  可以调用节点B,C....

2.3代码实现

1.插入

		bool _InsertR(Node*& root, const K& key)
		{
			if (root == NULL)  // 插入
			{
				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;
			}
		}

2.查找

		Node* _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
			{
				return nullptr;
			}

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

 3.删除：

在右树查找并删掉替换节点，然后将最小值赋值给父节点。

		bool _EraseR(Node*& root, const K& key)
		{
			if (root == NULL)
			{
				return false;
			}

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				// 找到了，root就是要删除的节点
				if (root->_left == nullptr)
				{
					Node* del = root;
					root = root->_right;
					delete del;
				}
				else if (root->_right == nullptr)
				{
					Node* del = root;
					root = root->_left;
					delete del;
				}
				else
				{
					Node* minRight = root->_right;
					while (minRight->_left)
					{
						minRight = minRight->_left;
					}
					K min = minRight->_key;

					// 转换成在root的右子树删除min
					_EraseR(root->_right, min);
					root->_key = min;
				}

				return true;
			}
		}

（三）二叉搜索树应用

1.场景一：用于排序《key模型》

      key模型，就是唯一属性作为键值，完成搜索和存储。要求唯一键具有"可比性"。主要应用场景是对一组不重复数据，进行搜索，排序，增删等操作。key模型的单一属性，决定被操作数据不可以重复。

2.场景二：用于搜索《key--value模型》

      key-value模型，要求设置唯一键，对其余属性数据进行查找，增删，排序等操作。应用场景：对于英文词典，汉译英，英译汉都是key-value场景。再比如我们可以用key-value模型统计重复元素出现的次数。同时，key-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)
		{}
	};

2.查找：

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

3. 插入：

		V& operator[](const K& key)
	{
		pair<Node*, bool> ret = Insert(key, V());
		return ret.first->_val;
	}
    pair<Node*, bool>  Insert(const K& key, const V& value)
	{	
		if (_root == nullptr)
		{
			_root = new Node(key, value);
			return make_pair(_root, true);
		}
		//查找要插入的位置
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//没找到+树中已有该值
			{
				return make_pair(cur, false);
			}
		}
			cur=new Node(key,value);

			if (cur->_key<parent->_key)
			{
				parent->_left = cur;
			}
			else {
				parent->_right = cur;
			}
			return make_pair(cur, true);

		
	}

4.删除：

		// 如果树中不存在key，返回false
		// 存在，删除后，返回true
		bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		if (nullptr == cur)
		{
			return false;
		}
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到了
			{
				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;
				}
				else if(cur->_right==nullptr){
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else {
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else {
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else {

					Node* minParent = cur;
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						parent = minRight;
						minRight = minRight->_left;
					}
					//cur = new Node(minRght->_key,minRight->_value);
					cur->_key = minRight->_key;
					cur->_val = minRight->_val;
					if (parent->_left == minRight)
					{
						parent->_left = minRight->_right;
					}
					else {
						parent->_right = minRight->_right;
					}
					
					delete minRight;
				}
				return true;
			}
			}
		return false;
	}

5.*测试：

一般我们将BST类实例化的时候，这个程序就有了功能。

例：维护一组英语单词数据<以英文作为键，中文作为属性>,可以提供英译汉，扩充字典，删除单词等功能。

void TestBSTree()
{
	KV::BSTree<string, string> dict;
	dict.InsertR("hello", "你好");
	dict.InsertR("baby", "婴儿");
	dict.InsertR("cat", "猫");
	dict.InsertR("dog", "狗");
	dict.InsertR("sort", "排序");
	// ...插入词库中所有单词
	string str;
	while (cin>>str)
	{
		KV::BSTreeNode<string, string>* ret = dict.FindR(str);
		if (ret == nullptr)
		{
			cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
		}
		else
		{
			cout << str << "中文翻译:" << ret->_value << endl;
		}
	}
}

（四）源码分享

1.二叉搜索树非递归版本

C++ 模拟实现搜索二叉树 · 刘敬一如/数据结构_blog1 - Gitee.comhttps://gitee.com/liu-jingyiru/data-structure-blog1/blob/master/C++%20%E6%A8%A1%E6%8B%9F%E5%AE%9E%E7%8E%B0%E6%90%9C%E7%B4%A2%E4%BA%8C%E5%8F%89%E6%A0%91

2.key-value模型

C++ 搜索二叉树KEY---VALUE模型 · 刘敬一如/数据结构_blog1 - Gitee.comhttps://gitee.com/liu-jingyiru/data-structure-blog1/blob/master/C++%20%E6%90%9C%E7%B4%A2%E4%BA%8C%E5%8F%89%E6%A0%91KEY---VALUE%E6%A8%A1%E5%9E%8B

                                      如有错误请多多指正，谢谢观看！

刘敬_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ BST（二叉搜索树）
a130737的专栏
07-19 2903
BST， 是一种完备二叉树。 顾名思义，
day14【c++】【递归三要素】【二叉树应用场景】● 理论基础● 递归遍历（必须掌握） ● 迭代遍历 ● 统一迭代
weixin_48629519的博客
10-07 334
【c++】【递归三要素】【二叉树应用场景】
二叉排序树（BST）
最新发布
m0_68805093的博客
08-30 218
二叉排序树的基本概念和代码
【二叉树进阶】二叉搜索树的结构、实现及应用
codewinter的博客
06-15 981
普通的二叉树单纯用来存储数据意义不大，还不如用数组和链表。普通数组和链表，面对一些需要频繁查找、插入、删除的场景，也很麻烦。所以这里引入了二叉搜索树。二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：二叉搜索树的结构特点带来的好处：定义二叉搜索树节点类模板： 定义二叉搜索树类模板： 2.2 默认成员函数的实现 2.2.1 构造函数 2.2.2 拷贝构造函数（要弄懂） 2.2.3 赋值运算符重载（要弄懂） 2.2.4 析构函数 三、二叉搜索树的相关接口实现 3.1 二叉搜索树
二叉搜索树的应用
iwkxi的博客
08-18 1231
首先，我们的目的是查找Key的时候随便查找Value，所以节点的结构、Insert和new的时候都要增加第二个参数Value。递归时，我们很容易知道当前节点的前一个节点是什么，但是无法知道下一个节点是什么，所以我们不能改变当前节点的右指针(后继指针)。再比如检查一篇文章单词释放拼写错误：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树，在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。考虑用栈来存储p、q的路径，让路径长的先走，路径相等后同时走，转换成求两个路径的交点。...
二叉树_C++_二叉树遍历_Vc_
09-29
在这个项目中，我们将探讨如何在C++中使用二叉链表来实现二叉树，并进行前序、中序和后序遍历。 **二叉链表**是二叉树在内存中的存储形式之一，每个节点包含一个数据元素和两个指向子节点的指针。二叉链表的节点...
c/c++二叉树详解，作业，学习参考
12-04
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的抽象数据类型，被广泛应用于各种算法设计和系统实现中。本资源包是针对C/C++编程语言的二叉树学习材料，涵盖了多种类型的二叉树及其操作，适合作为...
二叉树的应用
05-01
- **搜索与查找**：二叉搜索树（Binary Search Tree, BST）可以实现快速的插入、删除和查找操作。 - **表达式求值**：通过构造抽象语法树（Abstract Syntax Tree, AST），可以高效地解析和计算数学表达式。 - **文件...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
搜索二叉树（BST，Binary Search Tree）是一种特殊类型的数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子树的引用和一个指向右子树的引用。在搜索二叉树中，每个节点的键大于其左子树中任何节点的键...
study:学到的一些数据结构与算法（python或者C++实现）
05-17
C++实现时可以使用数组模拟堆结构，并维护堆性质。 4. **败者树 (Losers Tree)**: 败者树是一种用于快速查找最小元素的数据结构，常用于动态集合中的最小元素查询。败者树通常结合二叉堆一起使用，可以在线性时间...
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
BST树（二叉查找树）C++的实现
qq_41078889的博客
05-28 1720
二叉查找树（Binary Search Tree），也称二叉搜索树、有序二叉树（ordered binary tree），排序二叉树（orted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左、右子树也分别为二叉查找树； ......
二叉树的用途之一二叉搜索树
热门推荐
more_HH
07-21 2万+
    在学习数据结构的时候，也曾经学习过二叉树，以及前序排列、中序排列、后序排列等等，但是一直无缘使用它！二叉树可以干什么？    排序有快速排序，归并排序，查找有二分法，甚至直接遍历查找，二叉树的使用很少。    实际场景使用上，用的最多的是二叉平衡树，有种特殊的二叉平衡树就是红黑树，Java集合中的TreeSet和TreeMap,C++STL中的set,map以及LInux虚拟内存的管理，都...
【数据结构】——二叉搜索树
sjp11的博客
10-31 6411
目录 前言 二叉搜索树的概念 二叉搜索树的操作 树的节点实现 搜索树的基本结构 插入数据 查找 删除 拷贝构造函数 二叉搜索树的应用 前言 在c++中的容器里map和set的学习需要二叉搜索树的铺垫，也为后边的的红黑树和AVL树做铺垫，也就是说，今天主要讲搜索树的基本结构和应用。 二叉搜索树的概念 所有的根节点大于左子树的节点，小于右子树的节点的二叉树就叫做二叉搜索树。 二叉搜索的性质： 如果左子树不为空，则左子树上的所有节点都小于根节点。 如果右子树不为...
算法设计与应用之二叉搜索树
qq_42642142的博客
07-21 535
今年暑假参加了某C9院校的夏令营，面试时在算法方面被问到了二叉搜索树和堆结合的问题，当时太紧张了没答出来T T，也可以说是自己太菜了吧，因此下来之后又温习了下二叉树和堆的知识。写个笔记就当记录下自己的悔恨吧T T，同时树、图和堆在各种面试场合都是重点！ 二叉搜索树 二叉搜索树，是将二分搜索过程的动机应用于基于树的数据结构中，以更有效地支持更新操作。 二叉搜索树的特点就是存储在v的左子树的元素值均小于v的值e，存储在v的右子树的元素值均大于等于v的值e，因此二叉搜索树的中序遍历便是以非降序的顺序访问这种树中的
二叉树的详细分类与应用场景（Java代码实现）
我的技术日常
03-27 1833
1.二叉搜索树(Binary Search Tree) leetcode450.删除BST的结点 class Solution { public TreeNode deleteNode(TreeNode root, int key) { if (root == null) return null; if (key < root.val) { ...
二叉查找树的应用
liuhuiyi的专栏
07-17 1690
二叉查找树又称为二叉排序树， 它或者是一棵空树；或者是具有下列性质的二叉树：      （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；      （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；      （3）左、右子树也分别为二叉排序树；
[BST的构建][C++实现]
ChessC的博客
03-29 1064
今天前面碰到一题，判定给定的BST是否是合法的，因为BST性质，LDR遍历递增，根据这个来判定即可。但是碰到给定自行构建BST的时候，给定的输入是这样的： 5 1 5 2 3 1 0 0 3 4 5 4 0 0 6 0 0 什么意思呢，第一行为n和root，分别代表总共n个节点，并且root节点为序号root的节点。 之后每一行输入的是三个数，分别为val，left_idx，...
关于BST的插入，查找和删除
rookie_ly的博客
08-11 1571
一、建立BST节点结构struct node { int key; node *parent,*left,*right; };同时定义一个跟节点和一个空节点node *NIL,*root;二 、进行插入操作 首先判断树中如果没有节点，那么直接将要插入的节点当做根节点，并且设置它的父节点为NIL； 如果树中有根节点了，那么定义两个node节点x和y，x指向需要插到的位置，y指向x的父节
用c++实现二叉树的建立与遍历
05-30
下面是用C++实现二叉树的建立与遍历的示例代码： ```c++ #include using namespace std; // 定义二叉树结点 struct TreeNode{ int val; TreeNode* left; TreeNode* right; TreeNode(int x):val(x),left(NULL),...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘敬_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值