C++搜索二叉树的实现

最新推荐文章于 2024-11-11 22:14:43 发布
最新推荐文章于 2024-11-11 22:14:43 发布
阅读量633 收藏 6
点赞数 7
分类专栏： c++ 文章标签： c++ 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43016111/article/details/136470150
版权
本文详细介绍了使用C++模板类实现的搜索二叉树(BST)，包括BSTTreeNode结构，BSTree类的插入、查找和删除方法，以及测试用例展示了如何在不同场景下操作BST。
摘要由CSDN通过智能技术生成

搜索二叉树的实现

key

namespace key{
template<class k>
struct BSTreeNode
{
	BSTreeNode<k>* _left;
	BSTreeNode<k>* _right;
	k _key;

	BSTreeNode(const k& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}

};


template <class k>
class BSTree {
	typedef BSTreeNode<k> Node;
private:
	Node* _root = nullptr;
public:
	BSTree() = default;

	BSTree(const BSTree<k>& t) {
		_root = Copy(t._root);
	}

	BSTree<k>& operator=(BSTree<k>& t) {
		swap(_root, t._root);
		return *this;
	}

	~BSTree() {
		Destroy(_root);
	}

	bool FindR(const k& key) {
		return _FindR(_root, key);
	}

	bool InsertR(const k& key) {
		return _InsertR(_root, key);
	}

	bool EraseR(const k& key) {
		return _EraseR(_root, key);
	}

	bool Insert(const k& key) {
		if (_root == nullptr) {
			_root = new BSTreeNode<k>(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 BSTreeNode<k>(key);
		if (cur->_key > parent->_key) {
			parent->_right = cur;
		}
		else if (cur->_key < parent->_key) {
			parent->_left = cur;
		}
		return true;
	}

	bool 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 true;
			}
		}
		return false;
	}

	bool Erase(const k& key) {
		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
			{
				//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;
				}
				//2.右为空
				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;
					}
					delete cur;
				}
				//3.左右都不为空
				else
				{
					//找右树最小节点替代，也可以是左树最大节点替代（这里找的右树的最小结点）
					Node* pminright = cur; //preminright
					Node* minright = cur->_right;
					while (minright->_left) {
						pminright = minright;
						minright = minright->_left;
					}
					cur->_key = minright->_key;
					if (pminright->_left == minright) {
						//minright的最小节点没有左子树且为pminright的左孩子
						pminright->_left = minright->_right;
					}
					else
					{
						//minright的最小节点没有左子树且为pminright的右孩子
						pminright->_right = minright->_right;
					}
					delete minright;
				}
				return true;
			}
		}
		return false;
	}
	void InOrder() {
		_InOrder(_root);
		cout << endl;
	}
	void _InOrder(Node* root) {
		if (root == nullptr) {
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << "  ";
		_InOrder(root->_right);
		}

	protected:
		Node* Copy(Node* _root) {
			if (_root == nullptr)
				return nullptr;
			Node* newRoot = new Node(_root->_key);
			newRoot->_left = Copy(_root->_left);
			newRoot->_right = Copy(_root->_right);
			return newRoot;
		}

		void Destroy(Node* root) {
			if (root == nullptr) {
				return;
			}
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}

		bool _FindR(Node* root,const k& key) {
			if (root == nullptr)
				return false;
			if (root->_key == key) {
				return true;
			}
			if (root->_key > key) {
				return _FindR(root->_left, key);
			}
			else
			{
				return _FindR(root->_right, key);
			}
		}

		bool _InsertR(Node*& root, const k& key) {
			if (root == nullptr) {
				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;
			}
		}

		bool _EraseR(Node*& root, const k& key) {
			if (root == nullptr)
				return false;

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Node* del = root;

				// 开始准备删除
				if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					Node* maxleft = root->_left;
					while (maxleft->_right)
					{
						maxleft = maxleft->_right;
					}

					swap(root->_key, maxleft->_key);

					return _EraseR(root->_left, key);
				}

				delete del;

				return true;
			}
		}
	};
};

key-value

namespace key_value
{
	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)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:

		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				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, value);
			// 链接
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

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

		bool Erase(const K& key)
		{
			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
				{
					// 删除
					// 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;

					} // 2、右为空
					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;
							}
						}

						delete cur;
					}
					else
					{
						// 找右树最小节点替代，也可以是左树最大节点替代
						Node* pminRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight)
						{
							pminRight->_left = minRight->_right;
						}
						else
						{
							pminRight->_right = minRight->_right;
						}

						delete minRight;
					}

					return true;
				}
			}

			return false;
		}


		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

	protected:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}

测试用例

#include<iostream>
#include"BSTree.h"

using namespace std;
void TestBSTree()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	key::BSTree<int> t1;

	for (auto e : a)
	{
		t1.Insert(e);
	}

	t1.InOrder();

	t1.Erase(4);
	t1.InOrder();

	t1.Erase(14);
	t1.InOrder();

	t1.Erase(3);
	t1.InOrder();

	t1.Erase(8);
	t1.InOrder();


	for (auto e : a)
	{
		cout << "delete:" << e << "    ";
		t1.Erase(e);
		t1.InOrder();
	}

	t1.InOrder();
}

void TestBSTree2()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	key::BSTree<int> t1;

	for (auto e : a)
	{
		t1.InsertR(e);
	}
	t1.InOrder();

	t1.EraseR(10);
	t1.EraseR(14);
	t1.EraseR(13);
	t1.InOrder();


	for (auto e : a)
	{
		t1.EraseR(e);
		t1.InOrder();
	}

	t1.InOrder();
}

void TestBSTree3()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	key::BSTree<int> t1;
	for (auto e : a)
	{
		t1.InsertR(e);
	}

	t1.InOrder();

	key::BSTree<int> t2(t1);
	t2.InOrder();
}

void TestBSTree4()
{
	key_value::BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.Insert("string", "字符串");
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << ":" << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

void TestBSTree5()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };

	key_value::BSTree<string, int> countTree;
	for (auto str : arr)
	{
		//key_value::BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}


int main()
{
	TestBSTree();
	cout << "1" << endl;
	TestBSTree2();
	cout << "2" << endl;
	TestBSTree3();
	cout << "3" << endl;
	//TestBSTree4();
	cout << "4" << endl;
	TestBSTree5();
	cout << "5" << endl;
	return 0;
}
FreedanyTsui
关注
专栏目录
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
C++二叉树实现词频分析功能
08-28
C++二叉树实现词频分析功能 C++二叉树实现词频分析功能是通过使用二叉树数据结构来实现对词频的分析和统计，主要用于文本处理和信息检索领域。这种方法可以实现高效的词频统计和查询操作。 知识点一：二叉树数据...
C++搜索二叉树
RXY24601的博客
05-27 1408
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
C++ 搜索二叉树的删除
bananawolf的博客
02-06 664
情况1和情况2：如果这个父亲只有一个孩子要照顾，或者一个也没有，那么他想要脱身，只需要把这个孩子托付给他的长辈，没有就是nullptr，我们可以把这个过程叫托孤。2.情况三，月嫂的托孤，月嫂不一定是父亲的右孩子（左子树最大值的前提下），月嫂可能就是要被删除节点的左孩子，所以也要妥善处理。其次，他要满足照顾这两个孩子的条件，这个节点的key值要比左子树的每个节点key都要大，比右子树的每个节点key都要小，1.就不需要再找父节点了，这样还少了判断，被删除节点是父亲节点的左孩子还是右孩子。
C++ 搜索二叉树
异样旧日的博客
06-16 630
搜索二叉树的介绍与模拟实现
C++之搜索二叉树
一只小卷毛的博客
04-05 1284
本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。
二叉树的定义与C++实现
琅嬛福地
08-01 2069
树，是有限节点的集合。生活中的树是树根在下面，数据结构中的树的根在顶部，如下图： 公司的人员组织架构，董事长，总经理，副总。。。，这种模型可以用二叉树表示，还有一些压缩算法也用到了树结构。 树的几个概念 （1）度：有几个直接的孩子，例如，A的度是3，它有BCD三个孩子，B的度是2，它有EF两个孩子，度为0的节点也就是叶子节点（终端节点） （2）祖先：E的祖先是B,A , 从当前节点一直往上找 （3）叶子节点：下面的一层称为叶子节点，也可以称为终端节点。 （...
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++实现搜索二叉树
weixin_56667446的博客
04-15 1047
C++实现搜索二叉树 #pragma once using namespace std; template<class K> struct BSTreeNode { BSTreeNode<K>* _left; BSTreeNode<K>* _right; K _key; BSTreeNode(const K& key) :_left(nullptr) , _right(nullptr) , _key(key) {} }; template
C++泛型实现搜索二叉树
ye_yumo的博客
03-08 698
因此当二叉树为单支树，我们应当如何改进，使其性能都达到最优，就需要引入AVL树和红黑树，这些我们在后面也会陆续讲解和实现。第一类是K模型，结构中只需要存储Key即可，关键之就是所需要的值，一般用于检测某个值是否存在。二叉搜索树（BST，Binary Search Tree）又称为二叉排序树，空树也算。从根节点开始查找比较，比根大向右查找，比根小向左查找。最优情况下，二叉树为完全二叉树，其平均比较次数为。最差情况下，二叉树为单支树，其平均比较次数为。插入的次序不同，会影响到二叉树的结构。
C++【搜索二叉树】
芊樱烛渊的博客
10-23 1361
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树（每一棵子树都满足上面的特征）（这样我们的搜索二叉树就非常利于我们的搜索）比方说我们查找8,8比6大，找右子树，8比9小，找9的左子树，7比8小，找7的右子树，找到了。最多的查找次数是树的高度！这样就不是暴力查找了，而是利用了二叉树的特性。
【C++】————搜索二叉树
bhbcdxb123的博客
07-22 2070
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
C++二叉树实现.zip
08-20
本文将深入探讨使用C++实现二叉树的相关知识点，包括二叉树的定义、基本操作以及如何通过`Mytree.h`和`MytreeTest.cpp`文件来实现和测试一个二叉树。 首先，二叉树是一种特殊的树结构，每个节点最多有两个子节点，...
c++实现二叉树的基本功能
11-05
本文将深入探讨如何使用C++语言来实现二叉树的基本功能，包括其构建、销毁、以及各种遍历方法。我们将讨论前序、中序和后序遍历的递归和非递归实现，同时还会涉及计算树的深度和高度。 首先，要实现二叉树，我们...
p4:cmu 15213/15513 csapp 深入理解计算机系统（寄存器、标志位/条件码、set指令、大端法小端法、逻辑左右移和算数左右移、字长概念）
shanshan的博客
11-11 311
可以简单记成，setg表示set greater，但是机器指令的参数顺序与我们习惯的顺序不同，机器指令是从右到左比较的。标志位都是一位，他们不是你直接设置的，而是计算机的算术指令自己设置的。在这里是零拓展的意思，将al的一字节的全0拓展为4字节，左边都补0。综上，机器指令的流程是，比较两个数，得到一字节的0或1，然后根据返回类型的字长要求，拓展为相应位数的0或1。这里setg指令根据sf条件码，假设为0，（说明y>x），那么最低位的单个字节也都设为0。将单个寄存器的单个字节根据条件码的值设为1或0。
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1042
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
常用的c++特性--＞day02
m0_69093426的博客
11-06 659
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
C++ string(2)实现精讲
Jason_from_China的博客
11-06 1713
C++ string的使用我们已经讲解了，接下来我们会讲解string的实现，但是并不是每一个我都会实现，比如string删除有好几个，但是我会删除只是实现一个erase，首先是使用的次数频繁，其次是都大差不差，没有必要实现那么多，我这里只是把string整体的逻辑给实现，对string有一个更深入的了解提升代码能力和思维能力。注意事项1。
c++中，头文件包含iostream.h和`＜iostream＞`的差别
最新发布
南东先生
11-11 204
`iostream.h` 和`` 包含的是同一个文件，二者在功能上没有差别,只是写法不同。使用``是C++标准推荐的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值