【基】C/C++二叉搜索树的模拟实现

最新推荐文章于 2024-08-09 10:25:03 发布
最新推荐文章于 2024-08-09 10:25:03 发布
阅读量58 收藏
点赞数
分类专栏： 数据结构 文章标签： 1024程序员节 c++ 学习 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72575802/article/details/133906364
版权

文章目录

前言

二叉查找树（Binary Search Tree）或称二叉搜索树，二叉排序树
其可以是一棵空树，或者是具有下列性质的二叉树

  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
  • 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
  • 它的左、右子树也分别为二叉排序树

二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势；所以应用十分广泛，例如在文件系统和数据库系统一般会采用这种数据结构进行高效率的排序与检索操作。

1.树节点与树的结构体

  • 节点
template<typename T>
class BSTreeNode
{
public:

	BSTreeNode(const T& key)
		:_key(key)//初始化列表尽量与声明同序
		, _left(nullptr)
		, _right(nullptr)
	{}
	BSTreeNode<T>& operator=(BSTreeNode<T> node)
	{
		_key = node->_key;
		swap(_left, node->_left);
		swap(_right, node->_right);

		return *this;
	}

	BSTreeNode(const BSTreeNode& node)
	{
		_key = node->_key;
		_left = node->_left;
		_right = node->_right;
	}
	T _key;
	BSTreeNode* _left;
	BSTreeNode* _right;
};
  • 树的基本内容
template<typename T>
class BSTree
{
	typedef BSTreeNode<T> Node;
private:
	Node* root;
};

2.树的构造函数

BSTree()//用于创建空白树
		:root(nullptr)
	{}

	BSTree(const BSTree<T>& tree)//拷贝构造整棵树，一般采取递归方式，因为构造函数无法递归，所以采用再嵌套一层子函数
	{
		root=Copy(tree->root);
	}

	Node*& Copy(const Node*& _root)
	{
		if (_root == nullptr)
			return nullptr;
		Node* newroot = new Node(_root->_key);//利用别名 在下一层递归中"_root"变为_root->_right/left,通过别名实现了递归拷贝
		newroot->_left = Copy(_root->_left);
		newroot->_right = Copy(_root->_right);
		return newroot;
	}

在对使用多个单独联系的空间存储的数据进行复制拷贝时，经常会需要通过递归/迭代的思想来实现。
但迭代往往会让代码并不简短；而构造函数一般又不推荐直接进行递归操作，并且在此处传入的为树类型而非树节点类型，直接递归操作的思路并不好明晰；
故此处再次写一个子函数实现递归操作，接收树的根节点并返回拷贝的根节点实现拷贝构造

  • 需要注意的是，接收参数只有一个时递归时不要用this指针的内容，在递归到下一层时，this并不会也自动变化，如下代码错误
//void Copy(const Node*& _root)
	//{
	//	if (_root == nullptr)
	//		return;
	//	
	//	root->_key = _root->_key;
	//	root->_left = _root->_left;
	//	root->_right = _root->_right;
	//	Copy(_root->_left);
	//	Copy(_root->_right);
	//}错误写法 this.root不会在递归时同时变为root->right/left

3.赋值操作符重载

BSTree<T>&  operator=(const BSTree<T>& tree)//赋值重载 swap现代写法
	{
		BSTree<T> tmp =new BSTree<T>(tree);
		swap(root, tmp.root);
		delete tmp;
		return *this;
	}

或者采用如下写 因为写了拷贝构造 此处tree为深拷贝的临时变量 交换完自动销毁

	/*BSTree<T>& operator=(BSTree<T> tree)
	{
		swap(root, tree.root);
		return *this;
	}*/

4.插入_insert

常规的查找空节点

void insert(const T& key)//插入
	{
		if (root == nullptr)
			root= new Node(key);//调用构造函数
		else
		{
			Node* parent = nullptr;
			Node* cur = root;

			while (cur)//为空时找到位置
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;

				}
				
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;

				}
				
				else if (key == cur->_key)//已存在值，不插入
					return;

			}
			cur = new Node(key);

			if (parent->_key > key)//判断在节点左右
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
		}
	
	}

5.查找_Find

bool Find(const T& key)
	{
		Node* cur = root;//拷贝构造

		while (cur)//为空时找不到
		{
			if (key > cur->_key)
			{
				cur = cur->_right;

			}

			else if (key < cur->_key)
			{
				cur = cur->_left;
			}

			else if (key == cur->_key)//找到
				return true;
		}
		return false;
	}

6.删除_eraser

需要重点关注的即是 在删除节点的度为2时的替换关系 及剩余子树粘接回原树的逻辑

void Eraser(const T& key)
	{
		Node* cur = root;//浅拷贝
		Node* parent = nullptr;
		while (cur)//为空时找不到
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;

			}

			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}

				else if (key == cur->_key)//找到
				{
					if (!cur->_left && !cur->_right)//度为0
					{
						if (cur == root)
						{
							root = nullptr;
						}
						else
						{
							delete cur;
							cur = nullptr;
							return true;
						}
					
					}

					else if (!cur->_left && cur->_right)//度为1左为空
					{
						if (cur == root)
						{
							root = nullptr;
							return true;
						}
						else
						{
							if (cur == parent->_left)
							{

								parent->_left = cur->_right;
								delete cur;
								cur = nullptr;
								return true;

							}
							else
							{

								parent->_right = cur->_right;
								delete cur;
								cur = nullptr;
								return true;

							}
						}
						
						

					}
					else if (cur->_left && !cur->_right)//度为1,右为空
					{
						if (cur == root)
						{
							root = nullptr;
							return true;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
								delete cur;
								cur = nullptr;
								return true;
							}
							else
							{
								parent->_right = cur->_left;
								delete cur;
								cur = nullptr;
								return true;
							}
						}
						
					}
					else if (cur->_left && cur->_right)//度为2,寻找替换节点
					{
					
						Node* parent = nullptr;
							Node* minofbig = cur->_right;
							while (minofbig->_left)//右树最小值
							{
								parent = minofbig;//此处的用意是 删除后需要父节点将剩下节点“粘连”回主链
								minofbig = minofbig->_left;
							}
							swap(minofbig->_key, cur->_key);//只需交换值
							
							if (minofbig == parent->_right)//此时minofbig必无左节点
							{
								parent->_right = minofbig->_right;
							}
							else//此时为minofbig无左节点但任有右节点 将右子树接回原树
							{
								parent->_left = minofbig->_right;
							}
						
								cur= minofbig;
								delete cur;
								cur = nullptr;
								return true;
					}

				}
		}
		return false;

	}

7.中序排序

同样是为了符合使用习惯做出的嵌套

	void Inorder()
	{
		_InOrder(root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		

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

8.销毁_Destory

因为this不可显式传参 故再嵌套一层以符合使用习惯

~BSTree()//因为this不可显式调用 故再嵌套一层以符合使用习惯
	{
		_Destory(root);//即this.root
	}
	void _Destory(Node*& root)
	{
		if (root== nullptr)
			return;
	
		_Destory(root->_right);//在下一层递归中"root"变为root->_right,通过别名实现了递归删除
		_Destory(root->_left);
		//到此则说明root的right与left都为nullptr
		delete root;
		cur root= nullptr;//确保程序安全

	}

全部代码

#include<iostream>

template<typename T>
class BSTreeNode
{
public:

	BSTreeNode(const T& key)
		:_key(key)//初始化列表尽量与声明同序
		, _left(nullptr)
		, _right(nullptr)
	{}
	BSTreeNode<T>& operator=(BSTreeNode<T> node)
	{
		_key = node->_key;
		swap(_left, node->_left);
		swap(_right, node->_right);

		return *this;
	}

	BSTreeNode(const BSTreeNode& node)
	{
		_key = node->_key;
		_left = node->_left;
		_right = node->_right;
	}
	T _key;
	BSTreeNode* _left;
	BSTreeNode* _right;
};

template<typename T>
class BSTree
{
public:
	typedef BSTreeNode<T> Node;
	BSTree()//用于创建空白树
		:root(nullptr)
	{}

	BSTree(const BSTree<T>& tree)//拷贝构造整棵树，一般采取递归方式，因为构造函数无法递归，所以采用再嵌套一层子函数
	{
		root=Copy(tree->root);
	}

	Node*& Copy(const Node*& _root)
	{
		if (_root == nullptr)
			return nullptr;
		Node* newroot = new Node(_root->_key);//利用别名 在下一层递归中"_root"变为_root->_right/left,通过别名实现了递归拷贝
		newroot->_left = Copy(_root->_left);
		newroot->_right = Copy(_root->_right);
		return newroot;
	}

	//void Copy(const Node*& _root)
	//{
	//	if (_root == nullptr)
	//		return;
	//	
	//	root->_key = _root->_key;
	//	root->_left = _root->_left;
	//	root->_right = _root->_right;
	//	Copy(_root->_left);
	//	Copy(_root->_right);
	//}错误写法 this.root不会在递归时同时变为root->right/left

	BSTree<T>&  operator=(const BSTree<T>& tree)//赋值重载 swap现代写法
	{
		BSTree<T> tmp =new BSTree<T>(tree);
		swap(root, tmp.root);
		delete tmp;
		return *this;
	}

	/*BSTree<T>& operator=(BSTree<T> tree)
	{
		swap(root, tree.root);
		return *this;
	}*/
	//或者这么写 因为写了拷贝构造，此处tree为深拷贝的临时变量 交换完自动销毁

	~BSTree()//因为this不可显式调用 故再嵌套一层以符合使用习惯
	{
		_Destory(root);//即this.root
	}
	void _Destory(Node*& root)
	{
		if (root == nullptr)
			return;

		_Destory(root->_right);//在下一层递归中"root"变为root->_right,通过别名实现了递归删除
		_Destory(root->_left);
		//到此则说明root的right与left都为nullptr
		delete root;
		root = nullptr;//确保程序安全

	}

	void insert(const T& key)//插入
	{
		if (root == nullptr)
			root= new Node(key);//调用构造函数
		else
		{
			Node* parent = nullptr;
			Node* cur = root;

			while (cur)//为空时找到位置
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;

				}
				
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;

				}
				
				else if (key == cur->_key)//已存在值，不插入
					return;

			}
			cur = new Node(key);

			if (parent->_key > key)//判断在节点左右
			{
				parent->_left = cur;
			}
			else
			{
				parent->_right = cur;
			}
		}
	
	}
	bool Find(const T& key)
	{
		Node* cur = root;//浅拷贝

		while (cur)//为空时找不到
		{
			if (key > cur->_key)
			{
				cur = cur->_right;

			}

			else if (key < cur->_key)
			{
				cur = cur->_left;
			}

			else if (key == cur->_key)//找到
				return true;
		}
		return false;
	}

	bool Eraser(const T& key)
	{
		Node* cur = root;//浅拷贝
		Node* parent = nullptr;
		while (cur)//为空时找不到
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;

			}

			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}

			else if (key == cur->_key)//找到
				{
					if (!cur->_left && !cur->_right)//度为0
					{
						if (cur == root)
						{
							root = nullptr;
						}
						else
						{
							delete cur;
							cur = nullptr;
							return true;
						}
					
					}

					else if (!cur->_left && cur->_right)//度为1左为空
					{
						if (cur == root)
						{
							root = nullptr;
							return true;
						}
						else
						{
							if (cur == parent->_left)
							{

								parent->_left = cur->_right;
								delete cur;
								cur = nullptr;
								return true;

							}
							else
							{

								parent->_right = cur->_right;
								delete cur;
								cur = nullptr;
								return true;

							}
						}
						
						

					}
					else if (cur->_left && !cur->_right)//度为1,右为空
					{
						if (cur == root)
						{
							root = nullptr;
							return true;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
								delete cur;
								cur = nullptr;
								return true;
							}
							else
							{
								parent->_right = cur->_left;
								delete cur;
								cur = nullptr;
								return true;
							}
						}
						
					}
					else if (cur->_left && cur->_right)//度为2,寻找替换节点
					{
					
						Node* parent = nullptr;
							Node* minofbig = cur->_right;
							while (minofbig->_left)//右树最小值
							{
								parent = minofbig;//此处的用意是 删除后需要父节点将剩下节点“粘连”回主链
								minofbig = minofbig->_left;
							}
							swap(minofbig->_key, cur->_key);//只需交换值
							
							if (minofbig == parent->_right)//此时minofbig必无左节点
							{
								parent->_right = minofbig->_right;
							}
							else//此时为minofbig无左节点但任有右节点 将右子树接回原树
							{
								parent->_left = minofbig->_right;
							}
						
								cur= minofbig;
								delete cur;
								cur = nullptr;
								return true;
					}

				}
		}
		return false;

	}

	void Inorder()
	{
		_InOrder(root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		

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

private:
	Node* root;
};

总结

以上是二叉搜索树基本功能的模拟实现。

Dandely_蒲公英
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉查找树 减治法——C++代码
05-24
在描述中提到的C语言实现可能与上述C++代码类似，只是C语言不支持类，所以可能需要使用结构体和函数指针来模拟类的行为。不过，由于没有具体的代码示例，这里只能给出一个通用的二叉查找树的C++实现框架。如果你想要...
二叉搜索树（C#，C++）
10-11
在C++和C#这两种编程语言中实现二叉搜索树，我们需要关注以下关键点： 1. **数据结构定义**：首先，要定义一个表示节点的类或结构体，它包含键、值、左子节点和右子节点的引用。在C++中，可以定义为`struct Node`，...
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3676
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
C++二叉搜索树模拟实现
kkbca的博客
11-01 254
二叉搜索树讲解+模拟实现 Key模型和Ker-Value模型
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 1019
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
C++二叉搜索树
默的博客
05-05 584
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
【C++】二叉搜索树模拟实现（两种方法删除节点）
m0_62572672的博客
11-05 804
4.二叉树的删除（方法二：较为推荐）用引用结合递归的方式，具体逻辑没有变化，不过用引用简化了处理指针指向的问题，唯一注意的一点是在交换值之后递归的时候不能直接从根节点开始找。需要手动给出要删除节点所在子树的根节点，不然是找不到的。
【C++】二叉搜索树
m0_62179366的博客
10-24 2038
二叉搜索树的简单应用及实现。
C++：二叉搜索树的底层模拟实现
2301_76445610的博客
05-04 684
最后这个判断的前者是判断是否是正常情况，在正常情况中，最小右子树节点的父节点只是一个普通的节点，且最小右子树节点的父节点的左边一定是最小右子树节点，所以可以让父节点指向最小右字数节点的 右子树。是右指针还是左指针？a、删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。
C++笔记：二叉搜索树（Binary Search Tree）
ljh1257的博客
02-23 768
了解和实现二叉搜索树的接口，部分接口实现了迭代版和递归版，后面还记录了一下二叉搜索树的应用，还有其性能分析，及缺陷
模拟实现二叉搜索树超详解（C++）
m0_67430750的博客
05-06 738
模拟实现二叉搜索树，包括了递归和非递归两种版本。
a.rar_数据结构_C/C++_
08-12
二叉树的应用广泛，包括二叉搜索树、堆（如最大堆和最小堆）、平衡树（如AVL树和红黑树）等。这些数据结构在排序、搜索和优先级队列等场景中发挥着重要作用。 "排序.doc"讲述了各种排序算法，如冒泡排序、选择排序...
c/c++二叉树详解，作业，学习参考
12-04
2. **Treap**：Treap是随机化的二叉搜索树，它结合了二叉搜索树和堆的特性。每个节点都有一个优先级，通常由随机函数生成，这个优先级决定了树的形状。Treap的平均性能很好，插入、删除和查找操作的时间复杂度也为O...
功能非常齐全的二叉搜索树C++源码
10-05
本资源提供了C++实现的二叉搜索树，具有丰富的功能。首先，模版化的设计使得这个二叉搜索树可以适应不同类型的元素，不仅仅局限于整型或字符型，这样就大大增加了其灵活性和可复用性。模版类通常包含泛型编程的概念...
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 330
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 443
c++ error: ‘*’ does not name a type； did you mean ‘**’?
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 218
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
C++ - 函数重载
jiaowenjie的专栏
08-06 327
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C/C++算法详解：从高精度到图论网络流
"C/C++经典算法题目包含了大量的算法实现，包括高精度计算、计算几何、图论算法、数据结构、数论算法、字符串处理、模拟算法、特殊问题解决以及排序算法等多个方面，适合对ACM竞赛有兴趣的编程爱好者学习和参考。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值