C++二叉搜索树的模拟实现以及实现中常见的问题

最新推荐文章于 2024-09-26 09:13:29 发布
最新推荐文章于 2024-09-26 09:13:29 发布
阅读量116 收藏
点赞数 1
分类专栏： C++日常笔记 文章标签： 二叉搜索树 私有节点 递归删除 中序遍历 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sakeww/article/details/124226640
版权

目录

1.需要访问私有节点的另外一种方法

我们在写完中序遍历后，
我们要调用这个函数的时候我们需要调用这个函数
并且需要传递根节点
但是C++的成员（根节点）一般是私有的，拿不到这个节点
两种方法：
1.实现一个getroot函数，这样就可以直接访问到根节点
2.直接套用一层，写一个子函数

    void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
	.....//实现请看后面
	}

2.搜索二叉树的删除

在这里插入图片描述

递归删除

缺点：
当递归深度很高的时候，就会很麻烦

什么情况下，生成的二叉树深度很高？
给定的数组，按照有序或者接近有序的方式进行插入的时候就会很高

3.代码：

#pragma once
 

// key
namespace k {

	template<class K>
	struct BSTreeNode//struct BinarySearchTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;

		//构造函数
		BSTreeNode(const K& key)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	struct BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

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

		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
				{
					// 找到，开始删除
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)//根节点的情况
						{
							_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 (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}

						delete cur;
					}
					else//左右都不为空
					{
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}

						cur->_key = min->_key;

						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}

					return true;
				}
			}

			//没有找到这个值，说明删除失败
			return false;
		}

		//递归式插入
		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

		Node* FindR(const K& key)
		{
			return _FindR(_root, key);
		}

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

		//我们在写完中序遍历后，
		//我们要调用这个函数的时候我们需要调用这个函数
		//并且需要传递根节点
		//但是C++的成员（根节点）一般是私有的，拿不到这个节点
		//两种方法：
		//1.实现一个getroot函数，这样就可以直接访问到根节点
		//2.直接套用一层，写一个子函数
		void InOrder()
		{
			_InOrder(_root);
		}

	private://子函数设置称为私有的
		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;
		}

		//递归查找
		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;
		}

		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->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Node* min = root->_right;
					while (min->_left)
					{
						min = min->_left;
					}

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

					// 递归到右子树去删除
					return _EraseR(root->_right, key);
				}

				delete del;
				return true;
			}
		}

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

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

	void TestBSTree()
	{
		BSTree<int> t;
		int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9,5,5 };
		for (auto e : a)
		{
			t.Insert(e);
		}

		// 排序加去重
		t.InOrder();

		t.EraseR(7);
		t.InOrder();
		cout << endl;

		t.EraseR(5);
		t.InOrder();
		cout << endl;


		t.EraseR(0);
		t.InOrder();
		cout << endl;

		for (auto e : a)
		{
			t.EraseR(e);
			t.InOrder();
			cout << endl;
		}
	}
}


namespace KV
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;

		//pair<K, V> _kv;

		BSTreeNode(const K& key, const V& value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	struct BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

		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
				{
					// 找到，准备开始删除
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)
						{
							_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 (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}

						delete cur;
					}
					else
					{
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}

						cur->_key = min->_key;
						cur->_value = min->_value;


						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;

						delete min;
					}

					return true;
				}
			}

			return false;
		}



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

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

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

	void TestBSTree1()
	{
		// 字典KV模型
		BSTree<string, string> dict;
		dict.Insert("sort", "排序");
		dict.Insert("left", "左边");
		dict.Insert("right", "右边");
		dict.Insert("map", "地图、映射");
		//...

		string str;
		while (cin >> str)
		{
			BSTreeNode<string, string>* ret = dict.Find(str);
			if (ret)
			{
				cout << "对应中文解释：" << ret->_value << endl;
			}
			else
			{
				cout << "无此单词" << endl;
			}
		}
	}

	void TestBSTree2()
	{
		// 统计水果出现次数
		string arr[] = { "苹果", "西瓜","草莓", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		BSTree<string, int> countTree;
		for (auto& str : arr)
		{
			//BSTreeNode<string, int>* ret = countTree.Find(str);
			auto ret = countTree.Find(str);
			if (ret != nullptr)
			{
				ret->_value++;
			}
			else
			{
				countTree.Insert(str, 1);
			}
		}

		countTree.InOrder();
	}
}
sakeww
关注
专栏目录
模拟实现二叉搜索树超详解（C++）
m0_67430750的博客
05-06 769
模拟实现二叉搜索树，包括了递归和非递归两种版本。
C++ —— 二叉搜索树
原来45的博客
09-17 1115
二叉搜索树概念 二叉搜索树操作 1. 二叉搜索树的查找 2.二叉搜索树的插入 3. 二叉搜索树的删除 二叉搜索树的应用 1. K模型 2. KV模型 二叉搜索树的性能分析 二叉搜索树的实现（K&&KV）和测试（KV）
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3726
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
C++二叉搜索树模拟实现
kkbca的博客
11-01 277
二叉搜索树讲解+模拟实现 Key模型和Ker-Value模型
C++：二叉搜索树的底层模拟实现
2301_76445610的博客
05-04 704
最后这个判断的前者是判断是否是正常情况，在正常情况中，最小右子树节点的父节点只是一个普通的节点，且最小右子树节点的父节点的左边一定是最小右子树节点，所以可以让父节点指向最小右字数节点的 右子树。是右指针还是左指针？a、删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。
【C++】二叉搜索树模拟实现（两种方法删除节点）
m0_62572672的博客
11-05 824
4.二叉树的删除（方法二：较为推荐）用引用结合递归的方式，具体逻辑没有变化，不过用引用简化了处理指针指向的问题，唯一注意的一点是在交换值之后递归的时候不能直接从根节点开始找。需要手动给出要删除节点所在子树的根节点，不然是找不到的。
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 1055
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
C++二叉搜索树
默的博客
05-05 621
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
【C++笔记】二叉搜索树的模拟实现
kk702392702的博客
11-12 357
如果我们想要将新的节点连接上parent，要执行parent->_right = cur，这其实是将cur放到parent->_right指向的 **“空间”**，也就是要用到parent->_right的 **“左值”**(**“左值”表示空间，“右值”表示数据**)。
【C++】二叉搜索树
m0_62179366的博客
10-24 2069
二叉搜索树的简单应用及实现。
二叉查找树 减治法——C++代码
05-24
在C++中实现二叉查找树，一般会定义一个结构体或类来表示树节点，包括键、值和子节点指针。然后，提供一系列成员函数来执行基本操作，如`insert`（插入）、`search`（查找）、`delete`（删除）。以下是C++实现二叉...
二叉搜索树（C#，C++）
10-11
在C++和C#这两种编程语言中实现二叉搜索树，我们需要关注以下关键点： 1. **数据结构定义**：首先，要定义一个表示节点的类或结构体，它包含键、值、左子节点和右子节点的引用。在C++中，可以定义为`struct Node`，...
基于最优二叉搜索树的用户登录系统模拟
05-13
### 基于最优二叉搜索树的用户登录系统模拟 #### 一、实验背景与目标 本实验旨在通过模拟用户登录系统的过程，探讨如何利用最优二叉搜索树（特别是AVL树）来高效地管理用户信息。在实际应用中，用户登录系统需要...
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 968
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 988
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
最新发布
csdn_aspnet的专栏
09-26 856
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 663
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 664
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
C++实现数据结构：二叉搜索树与AVL树的构建与操作
问题要求建立给定数字的二叉搜索树，并模拟删除过程，这涉及到了BST的插入和删除操作。例如，删除操作通常包括找到待删除节点，然后根据其子节点情况调整树的结构以保持二叉搜索树的性质。 2. 判断一个给定的二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值