BSTREE（二叉搜索树）的介绍与模拟实现

已于 2025-04-25 23:51:12 修改
阅读量1.1k 收藏 21
点赞数 39
分类专栏： C++学习 文章标签： windows c++ 开发语言 学习 数据结构
于 2025-04-23 18:39:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87151064/article/details/147458538
版权

目录

二叉搜索树的介绍

1.概念介绍

2.性能分析

3.二叉搜索树的插入

4.二叉树的查找

5.二叉树的删除

2.二叉搜索树的模拟实现

1.创建节点

2.构造函数

3.二叉搜索树的成员变量

4.插入操作

5.查找操作

6.中序遍历

7.删除节点

8.析构函数

9.拷贝构造函数

10.赋值运算符的重载

3.⼆叉搜索树key和key/value使⽤场景

二叉搜索树的介绍

1.概念介绍

当学完了vector和list等容器和封装继承多态等特性后，接下来学习的就是BS树了，它的特性是：

1.所有的左子树小于根结点的值。

2.所有的右子树大于根结点的值。

3.它的左右子树也为二叉搜索树。

4.⼆叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值，具体看使⽤场景定义，后我
们学习map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不⽀持插⼊相等
值，multimap/multiset⽀持插⼊相等值。

2.性能分析

当它接近满二叉树时，它的性能接近log2N,这得益于它的结构，由于它的左子树小于根节点，右子树大于根节点，每次比较就干掉一半的值，效率非常高。

相反当它的结构到达极端情况时，搜索效率会降低到O(n)，退化成链表的结构。

3.二叉搜索树的插入

1.树为空，直接赋值给_root节点

2.树不为空，按照二叉搜索树的性质来，比根节点大，再去和右子树比较，比根节点小，再去和左子树比较，直到找到空位置。

注意：这个特性表示了它的插入顺序很可能影响搜索效率，比如在下面的二叉树中，如果我一开始就插入100这样的大值，那么根结点的右边就会不再插入值，会去左节点插入。

4.二叉树的查找

二叉树的查找是根据特性，当要查找的值比根节点大，向右子树走，比根节点小，向左子树走，直到找到与要查找的值相等的节点。

5.二叉树的删除

二叉树的删除我们分成几种情况来讨论：

1.要删除的节点左右子树都为空，由于左右子树都为空，所以删除它不影响其它节点，所以直接删除它即可。

2.删除的节点左子树为空但右子树不为空，这个时候把它的左子树托付给它的父节点即可，这时需要注意是向父节点的哪边插入。

3.删除的节点右子树为空但左子树不为空，这个时候和上述类似，思路就是把它的子节点托付给它的父节点，注意插入的方向即可。

4.删除的节点左右子树均不为空，这个时候我们要去查找该节点的右子树的最小值或者左子树的最大值来替代这个节点。这是由于二叉搜索树的特性导致的，该节点的右子树的所以节点大于该节点，这时需要找一个大于该节点的所以值中找一个最小的值，保证它比左子树的所有值大，比右子树的所有值小。类似的，左子树的所以节点的值都小于该节点，这时就需要在左子树中找一个最大的值来替代它，保证该值比左子树的所以值大，比右子树的所以值小。

当然，也可以这么说，找到它们左右子树中最特殊的来替代它就可以了。

这里可以结合图片来理解一下：

2.二叉搜索树的模拟实现

接下来进入到我们的模拟实现环节，通过模拟实现二叉搜索树我们可以更好的理解它的特性，我们通过前面的知识了解到，当它的结构趋近于满二叉树时，它的搜索效率是非常高的，一下干掉一半的值，每进入到下一个节点时就会让数减半，试想，一亿个数按近似于满二叉树存入，我们每次进入下一个节点时就干掉一半的值，举个例子，一亿个数查找一个数，每次进入下一个节点时我们直接就令查找的数目减半。大大提高我们的搜索效率！！！

1.创建节点

二叉搜索树的数据是存储在节点中的，我们先实现一个节点。这里使用了类模板来实现了泛型编程，可以传int,string等。

template<class T>
struct node
{
	node(const T& data )
	{
		_left = _right = nullptr;
		_val = data;
	}
	node<T>* _left;
	node<T>* _right;
	T _val = 0;
};

2.构造函数

构造函数我们不写，因为下面的私有变量中我们给了nullptr的缺省值，直接按缺省值进行初始化。

BSTREE()
{

}

3.二叉搜索树的成员变量

我们给一个跟节点即可，因为我们根节点存储的地址可以让操作者访问所有的二叉搜索树。

	private:
		node<T>* _root = nullptr;

4.插入操作

插入操作在上面介绍过了，在这里再简单说一下，根节点为空，直接new一个节点赋值给根节点，不为空根据二叉搜索树的特性，要插入的值比根节点小，向左走，大向右走，直到找到空位置进行插入。

bool Insert(const T& key)
{
	if (_root == nullptr)
	{
		auto root = new node<T>(key);
		_root = root;
		return true;
	}
		node<T>* parent = _root;
		node<T>* cur = _root;
		while (cur != nullptr)
		{
			if (cur->_val > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_val < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		/*cur->_val = key;*///理解一下这里为什么不对。。。原因是cur是空指针，对空指针赋值我简直太聪明了
		cur = new node<T>(key);
		if (parent->_val > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
}

5.查找操作

查找的操作和插入的操作有异曲同工之妙，只不过把插入的目的变成了判断相等。

比跟节点大，向右走，小，向左走，相等返回，若找到nullptr还未找到要查找的值返回false表示未找到。

	node<T>* Find(const T& key)
	{
		if (_root==nullptr)
		{
			return nullptr;
		}
		else
		{
			auto cur = _root;
			while (cur!=nullptr)
			{
				if (cur->_val > key)
				{
					cur = cur->_left;
				}
				else if (cur->_val < key)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;
				}
			}
		}
		return nullptr;
	}

6.中序遍历

由于外部无法访问二叉搜索树的根节点，所以遍历我们写成私有，类的内部可以访问私有值，让接口来调用这个私有即可。

接下来介绍写法的重点：递归

核心思想是把一个问题分成若干个小问题，当满足某个条件时返回作为终止条件。

中序遍历是左根右，假如我们先简化，先访问左节点的值，然后打印，再去访问右节点的值，打印。终止条件为传的地址为nullptr。然后再推广，当它们的节点还有很多时，人脑是无法很快反应过来的，我们要从总体去看一下，就是将问题分解为相似的子问题，依赖终止条件回溯结果。

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
private:
void _InOrder(node<T>* root)//中序遍历
{
	if (root==nullptr)
	{
		return ;
	}
	_InOrder(root->_left);
	cout << root->_val<<" ";
	_InOrder(root->_right);
}

7.删除节点

删除节点上述我们介绍过，这里强调一下特殊情况，

1.当cur==_root时，特殊处理一下，直接删掉根节点置空。

2.当_minright==_pminright时，这表明要删除的节点的右节点没有左孩子节点了，特殊处理，这这交换之后直接删掉有节点置空。

3.当cur==parent说明要删除的节点为头节点并且minright==pminright，特殊处理，交换值之后进行直接指向minright的右节点即可。

	   bool Erase(const T&key)
		{
		   if (_root==nullptr)
		   {
			   return false;
			}
		   else
		   {
			   node<T>* cur = _root;
			   node<T>* parent = _root;
			   while (cur)
			   {
				   if (cur->_val > key)
				   {
					   parent = cur;
					   cur = cur->_left;
				   }
				   else if (cur->_val < key)
				   {
					   parent = cur;
					   cur = cur->_right;
				   }
				   else
				   {
					   break;
				   }
			   }
		   
			   if (cur == nullptr)return false;
			   if (cur == _root && cur->_left == nullptr && cur->_right == nullptr)
			   {
				   delete _root;
				   _root = nullptr;
			   }
			   else if(cur->_left==nullptr&&cur->_right==nullptr)//左右孩子都为空
			   {
				   //不确定哪边孩子
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = nullptr;
					   delete cur;
				   }
				   else
				   {
					   parent->_right = nullptr;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else if (cur->_left == nullptr)//左孩子为空
			   {
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = cur->_right;
					   delete cur;
					   cur = nullptr;
				   }
				   else
				   {
					   parent->_right = cur->_right;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else if (cur->_right == nullptr)
			   {
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = cur->_left;
					   delete cur;
					   cur = nullptr;
				   }
				   else
				   {
					   parent->_right = cur->_left;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else
			   {
				   //找到右孩子的最小
				   auto pminright = cur->_right;
				   auto minright = cur->_right;
				   while (minright->_left != nullptr)
				   {
					   pminright = minright;
					   minright = minright->_left;
				   }
				   swap(minright->_val, cur->_val);
				   if (cur == parent && pminright == minright)
				   {
					   cur->_right = minright->_right;
					   delete minright;
					   minright = nullptr;
				   }
				   else if (pminright == minright)
				   {
					   delete minright;
					   minright = nullptr;
				   }
				   else
				   {
					   delete pminright->_left;
					   pminright->_left = nullptr;
				   }
			   }
			  }
		   return true;
		}

8.析构函数

析构函数应该是后续析构，不然删除根节点无法找到子节点，我们类似的简单想，应该先去左子树或者右子树去删除，假设只有三个节点，先去左子树，然后删除左子树，再去右子树，删除右子树，最后析构根节点。所以递归的结构就能写出来

		void shanchu(node<T>* root)
		{
			if (root == nullptr)return;
			shanchu(root->_left);
			shanchu(root->_right);
			delete root;
		}

9.拷贝构造函数

拷贝构造是先序构造，先构造一个值相等的根节点，再去构造左子树，最后构造右子树，递归结构也可以这样写出：

		 node<T>* copy(node<T>* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			node<T>* nroot = new node<T>(root->_val);//构造根节点。
			nroot->_left=copy(root->_left);//构造左节点
			nroot->_right=copy(root->_right);//构造右节点。
			return nroot;
		}

10.赋值运算符的重载

在进行重载时，要特别注意浅拷贝。去复用拷贝构造即可。

		BSTREE operator=(BSTREE<T>& t)
		{
			*this(t);
			return *this;
		}

下面给出整个的二叉搜索树key的实现代码方便查阅：

#pragma once
#include<iostream>
using namespace std;
namespace zb
{
	template<class T>
	struct node
	{
		node(const T& data )
		{
			_left = _right = nullptr;
			_val = data;
		}
		node<T>* _left;
		node<T>* _right;
		T _val = 0;
	};
	template<class T>
	class BSTREE
	{
	public:
		BSTREE()
		{

		}
		BSTREE(const BSTREE<T>& t)
		{
			_root=copy(t._root);
		}
		~BSTREE()//左右根
		{
			shanchu(_root);
			_root = nullptr;
		}
		BSTREE operator=(BSTREE<T>& t)
		{
			*this(t);
			return *this;
		}
		bool Insert(const T& key)
		{
			if (_root == nullptr)
			{
				auto root = new node<T>(key);
				_root = root;
				return true;
			}
				node<T>* parent = _root;
				node<T>* cur = _root;
				while (cur != nullptr)
				{
					if (cur->_val > key)
					{
						parent = cur;
						cur = cur->_left;
					}
					else if (cur->_val < key)
					{
						parent = cur;
						cur = cur->_right;
					}
					else
					{
						return false;
					}
				}
				/*cur->_val = key;*///理解一下这里为什么不对。。。原因是cur是空指针，对空指针赋值我简直太聪明了
				cur = new node<T>(key);
				if (parent->_val > key)
				{
					parent->_left = cur;
				}
				else
				{
					parent->_right = cur;
				}
				return true;
		}
		node<T>* Find(const T& key)
		{
			if (_root==nullptr)
			{
				return nullptr;
			}
			else
			{
				auto cur = _root;
				while (cur!=nullptr)
				{
					if (cur->_val > key)
					{
						cur = cur->_left;
					}
					else if (cur->_val < key)
					{
						cur = cur->_right;
					}
					else
					{
						return cur;
					}
				}
			}
			return nullptr;
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	   bool Erase(const T&key)
		{
		   if (_root==nullptr)
		   {
			   return false;
			}
		   else
		   {
			   node<T>* cur = _root;
			   node<T>* parent = _root;
			   while (cur)
			   {
				   if (cur->_val > key)
				   {
					   parent = cur;
					   cur = cur->_left;
				   }
				   else if (cur->_val < key)
				   {
					   parent = cur;
					   cur = cur->_right;
				   }
				   else
				   {
					   break;
				   }
			   }
		   
			   if (cur == nullptr)return false;
			   if (cur == _root && cur->_left == nullptr && cur->_right == nullptr)
			   {
				   delete _root;
				   _root = nullptr;
			   }
			   else if(cur->_left==nullptr&&cur->_right==nullptr)//左右孩子都为空
			   {
				   //不确定哪边孩子
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = nullptr;
					   delete cur;
				   }
				   else
				   {
					   parent->_right = nullptr;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else if (cur->_left == nullptr)//左孩子为空
			   {
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = cur->_right;
					   delete cur;
					   cur = nullptr;
				   }
				   else
				   {
					   parent->_right = cur->_right;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else if (cur->_right == nullptr)
			   {
				   if (parent->_val > key)//左孩子
				   {
					   parent->_left = cur->_left;
					   delete cur;
					   cur = nullptr;
				   }
				   else
				   {
					   parent->_right = cur->_left;
					   delete cur;
					   cur = nullptr;
				   }
				   return true;
			   }
			   else
			   {
				   //找到右孩子的最小
				   auto pminright = cur->_right;
				   auto minright = cur->_right;
				   while (minright->_left != nullptr)
				   {
					   pminright = minright;
					   minright = minright->_left;
				   }
				   swap(minright->_val, cur->_val);
				   if (cur == parent && pminright == minright)
				   {
					   cur->_right = minright->_right;
					   delete minright;
					   minright = nullptr;
				   }
				   else if (pminright == minright)
				   {
					   delete minright;
					   minright = nullptr;
				   }
				   else
				   {
					   delete pminright->_left;
					   pminright->_left = nullptr;
				   }
			   }
			  }
		   return true;
		}
	private:
		void _InOrder(node<T>* root)//中序遍历
		{
			if (root==nullptr)
			{
				return ;
			}
			_InOrder(root->_left);
			cout << root->_val<<" ";
			_InOrder(root->_right);
		}
		void shanchu(node<T>* root)
		{
			if (root == nullptr)return;
			shanchu(root->_left);
			shanchu(root->_right);
			delete root;
		}
		 node<T>* copy(node<T>* root)
		{
			if (root == nullptr)
			{
				return nullptr;
			}
			node<T>* nroot = new node<T>(root->_val);//构造根节点。
			nroot->_left=copy(root->_left);//构造左节点
			nroot->_right=copy(root->_right);//构造右节点。
			return nroot;
		}
	private:
		node<T>* _root = nullptr;
	};
}

3.⼆叉搜索树key和key/value使⽤场景

最后再介绍一下key/value的使用场景，这个本质是多存储一个value值。可以实现以下诸多操作：

中英互译，门牌号查找。注意key的值不可被修改，否则会打乱二叉树的顺序，乱序了。

【STL】二叉搜索树模拟实现
gaogo
10-10 1892
讲解二叉搜索树的特性。模拟实现二叉搜索树的插入、查找、中序遍历和删除（三种情况）
[数据结构] BSTree二叉搜索树的模拟实现
Darling_sheeps的博客
11-07 520
它或者是一颗空树，或者是具有下面性质的二叉树：若它的左子树不为空，左子树的结点的值都小于根结点的值；若它的右子树不为空，右子树结点的值都大于根结点；同时，它的左右子树又都是搜索二叉树。
二叉搜索树介绍和模拟实现
DR5200的博客
11-07 482
文章目录一.二叉搜索树概念 一.二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: (1). 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 (2). 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 (3). 它的左右子树也分别为二叉搜索树 二叉搜索树之所以被称作搜索树是因为该结构适合用来查找，如在上图中我们想要查找10，根节点为11，所以我们直接去11的左半部分找，7 < 10，所以我们去7的右半部分找，9 < 10，所以我们去9
二叉搜索树（BSTree）的介绍与模拟实现
work_hard423的博客
06-26 1236
1
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3859
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
C++二叉搜索树模拟实现
kkbca的博客
11-01 368
二叉搜索树讲解+模拟实现 Key模型和Ker-Value模型
二叉搜索树BSTree 模拟实现
aseraphe的博客
04-23 903
二叉搜索树 c++模拟实现 （key）（key-val）
二叉搜索树的简单模拟实现
2401_84568462的博客
04-24 630
二叉搜索树在C++学习中扮演着重要的角色。通过学习和实现二叉搜索树可以提高我们一下三种能力:数据结构与算法，掌握递归和迭代，提升问题解决能力，因此，学习二叉搜索树对于深入理解C++编程以及数据结构与算法都具有重要意义，能够为你的编程之路打下坚实的基础。
[数据结构] 模拟实现二叉搜索树(BSTree)
石墨博客
07-28 829
我们之前在学习二叉树的时候，主要突出了二叉树的结构特点，也就是二叉树的节点内存有val，两个指针分别指向左右子树：（具体内容见《手撕二叉树》tamplate<class T>//二叉树节点定义T _val;tempalte<class T>//二叉树结构public:private:如果二叉树仅仅空有复杂的结构特点，那么它的结构特点就会成为它的缺点——你会发现使用二叉树这个复杂的结构存储数据甚至不如用简单的链表结构存储数据。
二叉搜索树(BSTree)
FBI_BAIGOU的博客
01-26 1191
可以将上面的第1种和第2、3种情况合并一下，删除节点是可以划分为三种情况。
C++进阶：二叉搜索树介绍、模拟实现（递归迭代两版本）及其应用
qq_74415153的博客
03-20 1775
这次就来介绍二叉搜索树，和模拟
【C++进阶】二叉搜索树的介绍、模拟实现和相关习题
Stark_Skywalker的博客
07-22 941
二叉搜索树又叫二叉排序树、二叉查找树。可以为空，也可以不为空，具体有以下的特性：(二叉搜索树没有重复的值)在二叉搜索树中进行中序遍历时，每个节点只会被访问一次，因此遍历的时间复杂度为ON。这个复杂度表示无论树的结构如何（只要有 N 个节点），遍历树的时间是与节点数成线性关系的。但是给定一棵二叉树并不能在线性时间复杂度内转化为平衡二叉搜索树，因为涉及旋转等操作，时间复杂度不是线性的。
15.二叉树进阶（二叉搜索树的模拟实现和二叉搜索树的应用）
Q2691463021的博客
04-19 459
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:二叉搜索树：一颗二叉树，可以为空；如果不为空，满足以下性质：1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值3.它的左右子树也分别为二叉搜索树。
非序列实现MEMS聚焦功能
weixin_72050316的博客
04-25 149
非序列实现MEMS聚焦功能
CMD与PowerShell：Windows命令行工具的对比与使用指南
欢迎来到我的CSDN个人博客主页！
04-29 478
CMD（命令提示符）是Windows操作系统中的传统命令行解释器，起源于早期的MS-DOS操作系统。它提供了一个基于文本的界面，用户可以通过输入命令来执行各种操作。PowerShell是微软开发的更强大的命令行shell和脚本语言环境，最初发布于2006年。它基于.NET框架构建，提供了比CMD更丰富的功能和更强大的脚本能力。
顺序结构双链表的实现
weixin_45150754的博客
04-29 64
顺序结构双链表的实现
linux FTP服务器搭建
u012830675的博客
04-29 282
linux FTP服务器搭建
Pycharm（六）:可变与不可变类型
higerwy的博客
04-25 969
2.深浅拷贝都可以操作可变 和 不可变类型, 但是深浅拷贝一般不会操作不可变类型, 且你遇到的面试题几乎都是: 深浅拷贝操作可变类型；python中的赋值属于引用赋值，对于a，b，10都指向相同的内存空间，b是a的别名。1.所谓的深浅拷贝, 指的是: 拷贝的多与少. 深拷贝拷贝的多, 浅拷贝拷贝的少；，修改值之后会地址值会发生改变，变量a原来指向100对应的地址，修改值之后，不可变类型：整型，浮点型，布尔类型，字符串类型，元组类型。进行拷贝对拷贝的对象开辟新的内存空间进行存储，不会拷贝对象内部的。
人事管理系统6
最新发布
ABCDEEE7的博客
04-29 129
通过预编译方式传参，防止。为保证部门名称不重复，对。键值对传参，但需要修改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值