C++——二叉树搜索树

已于 2024-05-19 13:21:19 修改
阅读量705 收藏 23
点赞数 14
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-05-12 09:44:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_78794424/article/details/138709488
版权

前面写了初阶数据结构——二叉树；本文内容是来对它来进行结尾

目录

一概念

二实现

2.1查找

2.2插入 

2.3删除

完整源代码

三二叉树的应用 

 四二叉搜索树的性能分析

 五二叉搜索树相关的面试题

一概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

*  若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
** 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
***它的左右子树也分别为二叉搜索树

二实现

以下面的二叉搜索树为例：

2.1查找

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、走到到空，还没找到，这个值不存在。

bool find(const K& val)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_key < val)
		{
			cur = cur->_right;
		}
		else if (cur->_key > val)
		{
			cur = cur->_left;
		}
		else
		{
			//相等
			return true;
		}
	}
	return false;
}

2.2插入 

a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

bool insert(const K& val)
{
	if (_root == nullptr)
	{
		_root = new Node(val);
		return true;
	}
	else
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//相等
				return false;
			}
		}
		//判断要在parent的左还是右进行插入
		cur = new Node(val);
		if (parent->_key > val)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
}

2.3删除

a先通过二叉搜索树的性质找到节点的位置

b分析删除节点的左右孩子的情况：

无左右孩子节点(不考虑)

只有左孩子节点：删除之前把左孩子交给父亲节点

只有右孩子节点：删除之前把右孩子交给父亲节点

右孩子节点都有：有两种解决方法：

1找左节点的最大值的节点Max:Max的val与待删除的val进行交换；

2找右孩子的最小值的节点Min:Min的val与待删除的val进行交换；

以第二种为例来设计代码：

要注意对特殊情况的处理(删除根节点的情况)：

 

特别要记录cur(删除节点)的父节点(cur在父节点的左边还是右边不清楚) 

bool erase(const K& val)
{
	if (_root == nullptr) return false;
	Node* parent = nullptr;
	Node* cur = _root;

	while (cur)
	{
		if (cur->_key < val)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > val)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//找到删除位置
			//右孩子为空
			if (cur->_right == nullptr)
			{
				//cur是根节点
				if (parent == nullptr) _root = cur->_left;
				//cur的左孩子交给parent
				else
				{
					if (parent->_left == cur) parent->_left = cur->_left;
					else if (parent->_right == cur) parent->_right = cur->_left;
				}
				delete cur;
			}
			//右孩子为空
			else if (cur->_left == nullptr)
			{
				//cur==_root
				if (parent == nullptr) _root = cur->_right;
				else
				{
					if (parent->_left == cur) parent->_left = cur->_right;
					else if (parent->_right == cur) parent->_right = cur->_right;
				}
				delete cur;
			}
			//都有
			else
			{
				//找到右节点的最小值进行替换删除（左节点的最大值）

				//要删除的可能是_root patent不能为nullptr
				Node* ParentRightMin = cur;
				Node* RightMin = cur->_right;
				while (RightMin->_left)
				{
					ParentRightMin = RightMin;
					RightMin = RightMin->_left;
				}

				swap(RightMin->_key, cur->_key);

				//RightMin的右子树交给ParentRightMin
				if (ParentRightMin->_right == RightMin)
				{
					ParentRightMin->_right = RightMin->_right;
				}
				else
				{
					ParentRightMin->_left = RightMin->_right;
				}

				delete RightMin;
			}
			return true;
		}
	}
	return false;
}

完整源代码


#pragma once
#include<iostream>
using namespace std;

namespace bit
{
	template<class K>
	struct Node
	{
		Node(const K& key = K())
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}

		Node<K>* _left;
		Node<K>* _right;
		K _key;
	};
	template<class K>
	class BSTree
	{
		typedef Node<K> Node;
	public:
	
		bool insert(const K& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(val);
				return true;
			}
			else
			{
				Node* parent = nullptr;
				Node* cur = _root;
				while (cur)
				{
					if (cur->_key < val)
					{
						parent = cur;
						cur = cur->_right;
					}
					else if (cur->_key > val)
					{
						parent = cur;
						cur = cur->_left;
					}
					else
					{
						//相等
						return false;
					}
				}
				//判断要在parent的左还是右进行插入
				cur = new Node(val);
				if (parent->_key > val)
				{
					parent->_left = cur;
				}
				else
				{
					parent->_right = cur;
				}
				return true;
			}
		}

		bool find(const K& val)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < val)
				{
					cur = cur->_right;
				}
				else if (cur->_key > val)
				{
					cur = cur->_left;
				}
				else
				{
					//相等
					return true;
				}
			}
			return false;
		}

		bool erase(const K& val)
		{
			if (_root == nullptr) return false;
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//找到删除位置
					//右孩子为空
					if (cur->_right == nullptr)
					{
						//cur是根节点
						if (parent == nullptr) _root = cur->_left;
						//cur的左孩子交给parent
						else
						{
							if (parent->_left == cur) parent->_left = cur->_left;
							else if (parent->_right == cur) parent->_right = cur->_left;
						}
						delete cur;
					}
					//右孩子为空
					else if (cur->_left == nullptr)
					{
						//cur==_root
						if (parent == nullptr) _root = cur->_right;
						else
						{
							if (parent->_left == cur) parent->_left = cur->_right;
							else if (parent->_right == cur) parent->_right = cur->_right;
						}
						delete cur;
					}
					//都有
					else
					{
						//找到右节点的最小值进行替换删除（左节点的最大值）

						//要删除的可能是_root patent不能为nullptr
						Node* ParentRightMin = cur;
						Node* RightMin = cur->_right;
						while (RightMin->_left)
						{
							ParentRightMin = RightMin;
							RightMin = RightMin->_left;
						}

						swap(RightMin->_key, cur->_key);

						//RightMin的右子树交给ParentRightMin
						if (ParentRightMin->_right == RightMin)
						{
							ParentRightMin->_right = RightMin->_right;
						}
						else
						{
							ParentRightMin->_left = RightMin->_right;
						}

						delete RightMin;
					}
					return true;
				}
			}
			return false;
		}

		//进行套壳
		void _InOrder()
		{
			InOrder(_root);
			cout << endl;
		}

	private:
		void InOrder(const Node* _root)
		{
			if (_root == nullptr) return;
			InOrder(_root->_left);
			cout << _root->_key << " ";
			InOrder(_root->_right);
		}
	private:
		Node* _root=nullptr;
	};

	void Test1()
	{
		BSTree<int> sb;
		sb.insert(3);
		sb.insert(2);
		sb.insert(4);
		sb._InOrder();
		sb.erase(3);
		sb.erase(2);
		sb.erase(4);
		sb._InOrder();
	}
}

三二叉树的应用 

KV模型：

每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
比如：英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对：

//对二叉搜索树进行改造：
template<class K,class V>
struct Node
{
	Node(const K& key = K(),const V& val=V())
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
		,_val(val)
	{}

	Node<K,V>* _left;
	Node<K,V>* _right;
	K _key;
	V _val;
};
template<class K,class V>
class BSTree
{
	typedef Node<K,V> Node;
public:

	bool Insert(const K& val,const K& valute)
	{
		if (_root == nullptr)
		{
			_root = new Node(val,valute);
			return true;
		}
		else
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//相等
					return false;
				}
			}
			//判断要在parent的左还是右进行插入
			if (parent->_key > val)
			{
				parent->_left = new Node(val,valute);
			}
			else
			{
				parent->_right = new Node(val,valute);
			}
			return true;
		}
	}

	Node* Find(const V& val)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < val)
			{
				cur = cur->_right;
			}
			else if (cur->_key > val)
			{
				cur = cur->_left;
			}
			else
			{
				//相等
				return cur;
			}
		}
		return nullptr;
	}
	void _InOrder()
	{
		InOrder(_root);
	}

private:
	void InOrder(const Node* _root)
	{
		if (_root == nullptr) return;
		InOrder(_root->_left);
		cout << _root->_key << endl;
		InOrder(_root->_right);
	}
	Node* _root = nullptr;
};

void Test1()
{
	// 输入单词，查找单词对应的中文翻译
	BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("left", "左边、剩余");
	dict.Insert("right", "右边");
	dict.Insert("sort", "排序");
	// 插入词库中所有单词
	string str;
	while (cin >> str)
	{
		Node<string, string>* ret = dict.Find(str);
		if (ret == nullptr)
		{
			cout << "单词拼写错误，词库中没有这个单词:" << endl;
		}
		else
		{
			cout << "中文翻译:" << ret->_val << endl;
		}
	}
}

 四二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。 

但二叉搜索树在不同的场景可能会有以下结构：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：long2N
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N方

而在这种最差的情况下是有办法去去对它进行调整：将二叉树进行旋转，这个我们下文在说

 五二叉搜索树相关的面试题

 1. 二叉树创建字符串。oj链接
2. 二叉树的分层遍历1。oj链接
3. 二叉树的分层遍历2。oj链接
4. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。oj链接
5. 二叉树搜索树转换成排序双向链表。oj链接
6. 根据一棵树的前序遍历与中序遍历构造二叉树。 oj链接
7. 根据一棵树的中序遍历与后序遍历构造二叉树。oj链接
8. 二叉树的前序遍历，非递归迭代实现 。oj链接
9. 二叉树中序遍历 ，非递归迭代实现。oj链接
10. 二叉树的后序遍历 ，非递归迭代实现。oj链接

以上便是我在学习二叉搜索树的相关内容，有错误欢迎在评论区指正，谢谢！！ 

有时间要学习
关注
专栏目录
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
广工数据结构实验——平衡二叉树
07-06
平衡二叉树是二叉搜索树（Binary Search Tree, BST）的一个变体，它通过保持树的高度平衡来确保查找、插入和删除操作的高效性。 平衡二叉树的主要目标是避免最坏情况下的高度失衡，这可能导致搜索时间复杂度上升至O...
二叉查找树 减治法——C++代码
05-24
这种特性使得二叉查找树在搜索、插入和删除操作上的效率比普通二叉树更高。 减治法（Divide and Conquer，简称D&C）是计算机科学中一种常见的算法设计策略，通过将大问题分解为小问题来解决。在二叉查找树的应用中...
189. 轮转数组（C++）
最新发布
weixin_45813121的博客
09-25 343
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
q2315702359的博客
09-19 1094
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
Codeforces Round 973 (Div. 2) C. Password Cracking
puzhaoyu的博客
09-21 636
说明已经构建到了最右边，那么开始向左边构建。（写这题的时候一直不对，后来发现是忘记cin >> t了，归根结底还是不熟悉交互式编程的输入输出方式）猜一串二进制密码，每次可询问某串字符是否是密码的子串。从左到右不断构建ans字符串，每次不是加。，这可以通过询问得到。
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 649
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
C++ 字符串中的第一个唯一字符 - 力扣（LeetCode）
SikJ_2020_0_24的博客
09-21 293
比如：假设str[1] = 'b ‘a’的ASCII码值是97，那么count[ str[ 1 ] - 'a' ],也就是count[ 1 ]对应的是b出现的次数。所以遍历一次字符串就可以得到每个ASCII码值出现的次数，在遍历一次字符串，第一个ASCII码值所对应计数数组的值为1，就是第一个只出现一次的字符。由于小写字母一共有26个，所以利用ASCII码值来创建一个整形数组count，来保存对应ASCII码值出现的次数。它的第一个不重复的字符，并返回它的索引。
C++-Primer-Plus：18 个重点笔记
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 763
虽然从理论上讲，前缀递增/递减操作符由于不需要保存操作前的值而可能更高效，但这种差异在现代C++编程实践中往往被编译器的优化所掩盖。因此，在选择使用前缀还是后缀操作符时，更应该关注的是代码的清晰性和可读性，而不是微小的效率差异。在大多数情况下，遵循团队的编码规范或个人的编码习惯即可。最后，对于C++ Primer这样的经典书籍来说，它可能更多地是从语言规范和实现原理的角度来讨论这个问题，而不是从实际应用中的性能差异出发。
C++ 解析 RDP 协议
道亦无名
09-22 352
远程桌面协议（Remote Desktop Protocol, RDP）是微软开发的一种网络通信协议，用于提供远程桌面会话服务。它允许用户通过网络连接至远程计算机，并像使用本地计算机一样操作远程系统。本文档将详细探讨在C++环境中如何解析RDP协议，涵盖协议层次解析、连接过程管理、数据加密解密、功能数据处理、错误与异常处理以及协议版本适配等方面。
C++之模版的进阶
2301_81857941的博客
09-22 912
一个程序由若干个源文件共同实现，而每一个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。【优点】1.增强了代码的灵活性2.模版复用了代码，节省资源【缺陷】1.模版会导致代码膨胀问题2.出现模版错误时，错误原因难以定位。
C++—vector的常见接口与用法（正式进入STL）
GGbond665的博客
09-21 402
vector的常见接口与用法
C++如何进阶？ -- 整理一些学习资料
csdnzzt的博客
09-22 340
在学习完C++最基础的知识后，需要对C++有更近一步的认知。看门见山，首先贴出学习资料：侯捷老师的这几个视频是每个学习C++的人都应该仔细看几遍下来的，只看一遍是绝对记不住的具体来说必看的两本书，或者说，必看的两本书和一章节是STL源码剖析、Effective C++、深度探索C++对象模型第三章（虚函数）。而选看的两本书: More Effective C++、深度探索C++第三章以外的部分。
(c++)线程的创建、互斥锁的使用、线程数组
weixin_53112343的博客
09-20 263
但是线程可能在cpu分配的一个时间片中做不完10万次+1的操作，这时候cpu会被其他线程抢占，由于num1++不是一个原子操作（操作过程中可能会发生中断），导致++其实没有做完，所以num1的最终结果会小于100万。2.创建10个线程，每个线程都做10万次全局变量num2++操作，与前者不同的是，这次对num2++操作加入互斥锁，也就是让num2++成为一个“原子操作”（操作过程不会被中断），所以结果符合预期为100万。
59.【C语言】内存函数(memmove函数)
2401_85828611的博客
09-21 739
对比第59篇的memcpy函数。​ memmove多了:Copying takes place as if an intermediate buffer were used(复制就像中间的缓存区使用一样), allowing the destination and source to overlap. memcpy多了:, and should not overlap (for overlapping memory blocks, memmove is a safer approach). ​
C++第十二节课 模板初阶和string引入
weixin_47702917的博客
09-19 679
我们不需要写具体的函数，而是写这个函数的模板，编译器会根据模板生成对应的函数；两者的作用是等效的！用模板完成的功能有时候也叫泛型编程；可以通过定义多个模板参数来实现；函数模板根据调用，自己退到模板参数的类型，实例化出对应的函数；答案：不可以！规定不可以！
【c++】介绍
gcliyilin的博客
09-20 472
多态允许在不同类型的对象上调用相同的方法，实现更灵活和可扩展的代码。同时，C++还引入了函数重载和运算符重载等特性，使得编写更灵活和可读性更高的代码成为可能。但一旦掌握了C++的核心概念和技术，将能够编写高效、可维护和可扩展的代码。函数式编程则强调函数的纯粹性和不可变性，提供了一种更简洁和安全的编程方式。它结合了C语言的高效性和面向对象编程的特性，为程序员提供了丰富的工具和功能，以满足各种编程需求。C++还有丰富的标准库，提供了大量的函数和类，用于处理输入输出、字符串操作、容器、算法等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值