搜索二叉树详细介绍C++

已于 2024-05-27 19:41:54 修改
阅读量729 收藏 15
点赞数 12
分类专栏： C嘎嘎 数据结构 文章标签： c++ java 开发语言 树 二叉树 二叉搜索树
于 2024-04-02 18:25:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lim6ere/article/details/137200579
版权

`

文章目录

前言

在本篇文章中，我们将会学到数据结构中有关二叉树中一种特殊的结构-----搜索二叉树，它的主要目的就是为了搜索，我们还将会对搜索二叉树进行模拟实现。

一、搜索二叉树介绍

二叉树我们都已经学习过了，二叉搜索树就是对普通二叉树进行一些限制，有一些新的功能。
二叉搜索树又称二叉排序树，二叉查找树

如果它的左子树不为空，则左子树上所有结点的值都小于根节点的值。
如果它的右子树不为空，则右子树上所有结点的值都大于根节点的值。
左右子树也分别是一颗二叉搜索树

我们来看几个二叉树是不是二叉搜索树
在这里插入图片描述
这个就是一个二叉搜索树

在这里插入图片描述
这个就不是一个二叉搜索树，对于10这个节点，右节点的值必须大于这个10

性质：二叉搜索树中序遍历是一个递增序列

我们之前如果用排序+二分查找，时间复杂度也为O（N），但是在某个位置的插入删除时间复杂度为O（N），维护成本高。

二、二叉搜索树实现

普通的数据结构就是增删查改，但是在二叉搜索树是不允许修改的。对于存储重复值也无意义。

我们先看一下二叉搜索树框架结构

template<class K>
struct TreeeNode
{
	TreeeNode(const K& val)
		:_left(nullptr)
		,_right(nullptr)
		,_val(val)
	{}
	struct TreeeNode* _left;
	struct TreeeNode* _right;
	K _val;
};

template<class K>
class BSTree
{
public:
       //功能实现
private:
	typedef TreeeNode<K> Node;
	Node* _root=nullptr;

};

1.查找

我们利用二叉搜索树的性质查找，从根开始查找，进行一次遍历。
如果这个值比根节点大，我们就去右边查找。
如果这个值比根节点小，我们就去左边查找。
如果最后走到空，还没有找到，就说明这个值不存在。

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

}

2.插入

插入的逻辑也和查找的逻辑相似，我们需要分情况判断：
⭐️如果树为空，就新增节点，赋值给root，相等时我们不插入
⭐️树不为空，就按查找逻辑，找到合适的位置进行插入

我们找到合适的位置之和，还需要与上面的树进行链接，所以我们在进行查找的时候，还需要用一个父节点记录位置，方便链接

bool insert(const K&  val)
{
	//找到合适的位置插入

	if (_root == nullptr)
	{
		Node* newnode = new Node(val);
		_root = newnode;
		return true;
	}
	Node* cur = _root;
	//记录父亲
	Node* parent = _root;
	while (cur)
	{
		if (cur->_val > val)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_val < val)
		{
			parent = cur;
			cur = cur->_right;
		}
		//相等不插入
		else
		{
			return false;
		}
	}
	Node* newnode = new Node(val);
	//判断插入哪边,用值比较
	if (parent->_val >val)
	{
		parent->_left = newnode;
		return true;
	}
	else
	{
		parent->_right = newnode;
		return true;
	}
}

3.删除

首先查找这个元素是不是存在，不存在我们直接返回，如果存在可能会出现下面四种情况：
🌟叶子节点：直接删除
在这里插入图片描述
比如删除1，找到它的父亲，删除1，再将父亲指向的这个节点制空
🌟右子树为空，左子树不为空
在这里插入图片描述
比如删除14，我们找到14的父节点，cur的左子树连接到父亲节点，在删除当前节点
🌟左子树为空，右子树不为空
这个也是同样的道理

这三种情况可以进行合并为两种：
删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除

🌟左右子树都存在

在这里插入图片描述

我们想要删除3，怎末删除呢？？删除之后这棵树还保持原有的特性

这里我们采用替换法删除，找一个可以替换的节点，交换两个位置的值，再删除这个替换节点。

什么节点可以进行替换呢？？我们有两种选择：

左子树最右节点，也就是左子树中值最大的那个节点
右子树最左节点，也就是右子树中值最小的那个节点

我们采用右子树最左节点来进行操作，

	//删除
	bool erase(const K&val)
	{
		Node* cur = _root;
		//先找到删除节点
		
		//记录父亲
		Node* parent = _root;
		while (cur)
		{
			if (cur->_val > val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_val < val)
			{
				parent = cur;
				cur = cur->_right;
			}
			//相等找到了
			else
			{
			    //删除操作
			}
	   }
    }

🧐🧐我们先看前两种情况

//左子树为空
if (cur->_left == nullptr)
{
	if (cur == parent->_left)
	{
		parent->_left = cur->_right;
	}
	else
	{
		parent->_right = cur->_right;
	}
	delete cur;
	return true;
}
//右子树为空
else if (cur->_right == nullptr)
{
	if (cur == parent->_left)
	{
		parent->_left = cur->_left;
	}
	else
	{
		parent->_right = cur->_left;
	}

	delete cur;
	return true;
}

我们看一下这这段代码？？？？
在这里插入图片描述
一般情况确实符合，我们来看一下面这种极端情况
在这里插入图片描述

如果我们想要删除8，我们来走一下代码
parent和cur都指向8这个节点，这个if,else语句不成立，根本就不会进去，就把这个节点给删除了，那我们也拿不到后面的节点了。
所以我们需要特殊处理。root直接指向它的孩子

 if (cur->_left == nullptr)
{
		 if (_root == cur)
		 {
			 _root = _root->_right;
		 }
		 else
		 {
			 if (cur == parent->_left)
			 {
				 parent->_left = cur->_right;
			 }
			 else
			 {
				 parent->_right = cur->_right;
			 }

		 }
		 delete cur;
		 return true;
}
//右子树为空
else if (cur->_right == nullptr)
{
		 if (_root == cur)
		 {
			 _root = _root->_left;
		 }
		 else
		 {
			 if (cur == parent->_left)
			 {
				 parent->_left = cur->_left;
			 }
			 else
			 {
				 parent->_right = cur->_left;
			 }
		 }
		delete cur;
		return true;
}

🧐🧐我们看一下两个节点都存在的情况

替换法：找到右子树的最左节点进行，找到后交换两者的值，最后删除这个替换节点，再通过这个替换节点的父亲把这个替换节点维护起来（可能存在右孩子）

我们以删除3为例子
在这里插入图片描述

首先找到替换节点4，标记为RightMin，顺表找到它的父亲节点RightParent 。交换两个节点的值
在这里插入图片描述

接下来我们就可以对3进行删除，同时维护这个节点
在这里插入图片描述

我们看一下代码实现`

else
{
	//替换法删除

	//先找到替换的位置和父亲,右子树最左节点
	Node* RightMin = cur->_right;
	Node* RightParent = cur;
	while (RightMin->_left)
	{
		RightParent = RightMin;
		RightMin = RightMin->_left;
	}
	//交换
	std::swap(cur->_val, RightMin->_val);
	RightParent->_left = RightMin->_right;


	delete RightMin;
	return true;

}

这样我们就实现了这个删除操作，但是我们看一下是不是有什么情况没有考虑呢？？

我们看一下这种情况，我们要删除8
在这里插入图片描述
我们交换了之后
在这里插入图片描述

我们发现没有左子树，这句代码RightParent->_left = RightMin->_right;就会崩溃，空指针的访问。
我们先还需要特殊处理

else
{
	//替换法删除

	//先找到替换的位置和父亲,右子树最左节点
	Node* RightMin = cur->_right;
	Node* RightParent = cur;
	while (RightMin->_left)
	{
		RightParent = RightMin;
		RightMin = RightMin->_left;
	}
	//交换
	std::swap(cur->_val, RightMin->_val);
	if (RightParent->_left == RightMin)
		RightParent->_left = RightMin->_right;
	else
		RightParent->_right = RightMin->_right;

	delete RightMin;
	return true;

}

完整代码

template<class K>
class BSTree
{
public:
	//强制生成默认构造
	BSTree() = default;
	//插入
	bool insert(const K&  val)
	{
		//找到合适的位置插入

		if (_root == nullptr)
		{
			Node* newnode = new Node(val);
			_root = newnode;
			return true;
		}
		Node* cur = _root;
		//记录父亲
		Node* parent = _root;
		while (cur)
		{
			if (cur->_val > val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_val < val)
			{
				parent = cur;
				cur = cur->_right;
			}
			//相等不插入
			else
			{
				return false;
			}
		}
		Node* newnode = new Node(val);
		//判断插入哪边,用值比较
		if (parent->_val >val)
		{
			parent->_left = newnode;
			return true;
		}
		else
		{
			parent->_right = newnode;
			return true;
		}
	}
	//查找
	bool find(const K& val)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_val > val)
			{
				cur = cur->_left;
			}
			else if (cur->_val < val)
			{
				cur = cur->_right;
			}
			//相等不插入
			else
			{
				return true;
			}
		}
		return false;

	}
	//中序遍历

	//采用递归，必须要进行参数传递，封装一层；
	void Inorder()
	{
		_Inorder(_root);
	}

	//删除
	bool erase(const K&val)
	{
		Node* cur = _root;
		//先找到删除节点
		
		//记录父亲
		Node* parent = _root;
		while (cur)
		{
			if (cur->_val > val)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_val < val)
			{
				parent = cur;
				cur = cur->_right;
			}
			//相等找到了
			else
			{
				//左子树为空
				 if (cur->_left == nullptr)
				{
					 if (_root == cur)
					 {
						 _root = _root->_right;
					 }
					 else
					 {
						 if (cur == parent->_left)
						 {
							 parent->_left = cur->_right;
						 }
						 else
						 {
							 parent->_right = cur->_right;
						 }

					 }
					 delete cur;
					 return true;
				}
				//右子树为空
				else if (cur->_right == nullptr)
				{
					 if (_root == cur)
					 {
						 _root = _root->_left;
					 }
					 else
					 {
						 if (cur == parent->_left)
						 {
							 parent->_left = cur->_left;
						 }
						 else
						 {
							 parent->_right = cur->_left;
						 }
					 }
					delete cur;
					return true;
				}
				//两个孩子
				else
				{
					//替换法删除

					//先找到替换的位置和父亲,右子树最左节点
					Node* RightMin = cur->_right;
					Node* RightParent = cur;
					while (RightMin->_left)
					{
						RightParent = RightMin;
						RightMin = RightMin->_left;
					}
					//交换
					std::swap(cur->_val, RightMin->_val);
					if(RightParent->_left==RightMin)
					      RightParent->_left = RightMin->_right;
					else
						RightParent->_right = RightMin->_right;

					delete RightMin;
					return true;

				}
			}
		}
		return false;
	}
 private:
  typedef TreeeNode<K> Node;
  Node* _root=nullptr;
};

三、二叉搜索树递归实现

1.查找

我们查好就很容易完成了，这个值大，就去右边找。这个值小就去左边找。找到空了就返回。逻辑很简单。

不同的是我们需要封装一层，外边传递的参数不符合我们递归的参数。

bool Rfind(const K& val)
{
   return _Rfind(val, _root);
}


	bool _Rfind(const K& val, Node* root)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_val > val)
		{
			return  _Rfind(val, root->_left);
		}
		else if (root->_val < val)
		{
			return  _Rfind(val, root->_right);
		}
		else
		{
			return true;
		}
	}

2.插入

找到合适的位置进行插入就可以.

void Rinsert(const K& val)
{
   _Rinsert(val,_root);
}

我们需要注意的是如何进行链接并且返回。
在这里插入图片描述
我们想要插入15，我们如何通过递归找到这个父节点？？？

bool _Rinsert(const K& val,Node*& root)这就可以完成

在这里插入图片描述
传参传递的是引用，这里的root是上一层root->right的别名。
所以实际上就是让14指向了15。这个引用只在最后一层起作用。
在这里插入图片描述

bool _Rinsert(const K& val,Node*& root)
{
	if (root == nullptr)
	{
		//开节点插入
		root= new Node(val);
		return true;
	}
	if (root->_val > val)
	{
		return _Rinsert(val, root->_left);
	}
	else if(root->_val < val)
	{
		return _Rinsert(val, root->_right);
	}
	else
	{
		return false;
	}
}

3.删除

找到合适的位置删除，但是这里的删除要分情况删除。

一个孩子的情况很简单，我们主要看一下两个孩子的情况

我们还是需要用到替换法删除，但是我们不需要找父亲了；我们这里有引用。
我们这里转换成去这棵树进行删除。直接将要删除的节点有两个孩子，变成只有一个孩子或是没有孩子的情况

void Rerase(const K& val)
{
   _Rerase(val, _root);
}

	bool _Rerase(const K& val, Node*& root)
	{
	//这里所有情况都包含，我们不用找父亲了。
		if (root == nullptr)
		{
			return false;
		}
		if (root->_val > val)
		{
			return _Rerase(val, root->_left);
		}
		else if (root->_val < val)
		{
			return _Rerase(val, root->_right);
		}
		//找到了
		else
		{
			Node* del = root;
			//判断一个孩子情况
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			//两个孩子
			else
			{
				//替换法删除.右子树最左节点
				Node* RightMin = root->_right;
				while (RightMin->_left)
				{
					RightMin = RightMin->_left;
				}
				//交换
				std::swap(RightMin->_val, root->_val);
				//转换成去这棵树删除
				return _Rerase(val, root->_right);
			}
			delete del;
		}
		return true;
	}

四、二叉搜索树性能分析

插入和删除之前都必须先进行查找，那么查找的效率就是二叉搜索树中操作的性能。
插入的顺序不同，最终树的形状也是不同的。

我们可以发现，最差就是查找高度次，有人说，这不就是logn吗！！

但是对于同一个关键码集合，插入的顺序不同，极有可能得到不同的·二叉搜索树。
在这里插入图片描述
💗最优的情况：二叉搜索树为完全二叉树，平均比较次数就是logn
💗最差的情况：就像右图所示，退化为类似单只，平均比较次数就是。（接近有序插入）

如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上
场了

五、二叉搜索树应用

1.K模型

k模型只有key作为关键字，在结构中只需要存储key就可以。
快速查找某个值是否存在

使用：
🌟日常生活中我们开车进入小区中，会进行车牌的扫描，快速查找，看你是否是这个小区的车型，若果是抬杆，进去。如果不存在，就进不去
🌟查看一个单词是否拼写错误，在词库中所有单词构建一颗二叉搜索树，在二叉搜索树中查找该单词是否存在。

2.KV模型

每一个对应的key都有一个与之对应的value,即<K,V>键值对
快速通过一个值查找另一个值是否存在。

使用：
🌟高铁刷身份进站，每一个乘客都有一个身份证号，如果在平台上买票了，就会更新这个身份信息。
🌟查找某个单词的意思，<中文，英文>也构成了键值对
🌟统计单词出现的个数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

我们上面写的是K模型的，我们要实现KV模型，只需要稍微已修改就可以


namespace KV
{
	// 节点
	template<class K,class V>
	struct BSTreeNode
	{
		BSTreeNode* _left;
		BSTreeNode* _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:

		//查找
		Node*  Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
			
		}
		//增加(不能增加重复元素)
		bool Insert(const K& key,const V&value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,value);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;

			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return false;
				}
			}
			//插入
			cur = new Node(key,value);
			if (cur->_key > parent->_key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}
		//删除
		bool Erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//只有一个左孩子
					if (cur->_right == nullptr)
					{
						Node* del = cur;
						//没有父亲，就是根节点
						if (cur == _root)
						{
							_root = _root->_left;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}
						delete del;
						return true;
					}
					else if (cur->_left == nullptr)
					{
						Node* del = cur;
						//没有父亲，就是根节点
						if (cur == _root)
						{
							_root = _root->_right;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
							delete del;
							return true;
						}
					}
					//两个节点
					else
					{

						Node* RightMinP = cur;
						Node* RightMin = cur->_right;
						while (RightMin->_left)
						{
							RightMinP = RightMin;
							RightMin = RightMin->_left;
						}
						//交换
						swap(RightMin->_key, cur->_key);
						//托管
						if (RightMin == RightMinP->_left)
						{
							RightMinP->_left = RightMin->_right;
						}
						else
						{
							RightMinP->_right = RightMin->_right;
						}
						delete RightMin;
						return true;
					}
				}
			}
			return false;
		}
		void Inorder()
		{
			_Inorder(_root);
		}


	private:
		//中序
		void _Inorder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_Inorder(root->_left);
			cout << root->_key << " " << root->_value << endl;;
			_Inorder(root->_right);
		}

		Node* _root = nullptr;
	};
}

我们看一个常用例子，统计出现的个数

int main()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
   "苹果", "香蕉", "苹果", "香蕉" };
	KV::BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		// 先查找水果在不在搜索树中
		// 1、不在，说明水果第一次出现，则插入<水果, 1>
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		// 2、在，则查找到的节点中水果对应的次数++
		else
		{
			ret->_value++;
		}
	}
	countTree.Inorder();
}

在这里插入图片描述

我们是按照KV模型中K的值进行比较，这里的K是string,按照ASCII码进行比较。

总结

以上就是今天要讲的内容，本文仅仅详细介绍了二叉搜索树的相关内容。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘

lim 鹏哥
关注
专栏目录
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
二叉树-基于C++实现的平衡二叉树.zip
04-26
本压缩包文件“二叉树-基于C++实现的平衡二叉树.zip”包含了一个关于使用C++编程语言实现平衡二叉树的实例，这对于我们理解平衡二叉树的原理和实际操作至关重要。 平衡二叉树（Balanced Binary Tree）是一种特殊的...
C++搜索二叉树
RXY24601的博客
05-27 1404
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
C++之搜索二叉树
一只小卷毛的博客
04-05 1280
本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。
C++ 搜索二叉树的删除
bananawolf的博客
02-06 656
情况1和情况2：如果这个父亲只有一个孩子要照顾，或者一个也没有，那么他想要脱身，只需要把这个孩子托付给他的长辈，没有就是nullptr，我们可以把这个过程叫托孤。2.情况三，月嫂的托孤，月嫂不一定是父亲的右孩子（左子树最大值的前提下），月嫂可能就是要被删除节点的左孩子，所以也要妥善处理。其次，他要满足照顾这两个孩子的条件，这个节点的key值要比左子树的每个节点key都要大，比右子树的每个节点key都要小，1.就不需要再找父节点了，这样还少了判断，被删除节点是父亲节点的左孩子还是右孩子。
【C++】————搜索二叉树
bhbcdxb123的博客
07-22 2068
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。正所谓：君子可内敛不可懦弱，面不公可起而论之。3.成年人的世界，只筛选，不教育。
C++【搜索二叉树】
芊樱烛渊的博客
10-23 1359
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:若它的左子树不为空，则左子树上所有节点的值都小于根节点的值若它的右子树不为空，则右子树上所有节点的值都大于根节点的值它的左右子树也分别为二叉搜索树（每一棵子树都满足上面的特征）（这样我们的搜索二叉树就非常利于我们的搜索）比方说我们查找8,8比6大，找右子树，8比9小，找9的左子树，7比8小，找7的右子树，找到了。最多的查找次数是树的高度！这样就不是暴力查找了，而是利用了二叉树的特性。
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++ 二叉树
m0_58697609的博客
09-25 939
二叉搜索树又称二叉排序树，他或者是一棵空树，或者是具有以下性质的二叉树：①若它的左子树不为空，则左子树上所有节点的值都小于根节点的值②若它的右子树不为空，则右子树上所有节点的值都大于根节点的值③它的左右子树也分别为二叉搜索树。
完全二叉树、搜索二叉树、平衡二叉树和满二叉树（C++）
ymhdt的博客
05-21 1594
完全二叉树是这样定义的：若二叉树的深度为 h，除第 h 层外，其它各层的结点数都达到最大个数，第 h 层所有的叶子结点都连续集中在最左边，这就是完全二叉树。（第 h 层可能包含 [1~2h] 个节点）上面的定义看起来比较复杂。所有节点只存在3种情况：1、有左右2个孩子；2、只有左孩子；3、没有孩子（叶节点），即不存在只有右孩子的情况；我们采用层序遍历的方式遍历节点，当遍历到某一个节点，它只有左孩子，或者没有孩子，则后序所有节点一定都是叶节点。如下所示是完全二叉树节点的左子树只包含小于当前节点的数。
【C++】搜索二叉树
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
10-29 2026
二叉搜索树的功能介绍
平衡二叉树详解及C++实现
c661280411470yb的博客
06-08 782
平衡二叉搜索树
二叉树-基于C++实现的二叉树操作.zip
04-26
总结来说，"二叉树-基于C++实现的二叉树操作.zip"这个压缩包文件很可能包含了以上讨论的二叉树概念、节点类定义、基本操作（插入、搜索、删除）以及遍历算法的C++代码实现。通过学习和理解这些内容，你可以掌握...
二叉树-基于C++实现的平衡二叉树的旋转.zip
04-26
本压缩包文件“二叉树_基于C++实现的平衡二叉树的旋转.zip”关注的是平衡二叉树的实现，特别是旋转操作，这在高效查找和维护平衡方面起着关键作用。 平衡二叉树（如AVL树和红黑树）是二叉搜索树的一个变种，它通过...
讲解非常详细的C++二叉树的创建与遍历
05-27
本文详细介绍了如何在C++中创建二叉树及其遍历方法。通过这些基础知识的学习，可以帮助初学者更好地理解二叉树这一重要数据结构，并为进一步学习高级算法打下坚实的基础。希望本文能够帮助读者更好地掌握二叉树的...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
最新发布
weixin_43845922的博客
11-02 205
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2261
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1175
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++实现二叉树广度优先搜索
"二叉树的广度搜索遍历，C++实现的代码示例" 在计算机科学中，二叉树是一种数据结构，它由节点（或称为顶点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的遍历是指按照特定顺序访问树中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lim 鹏哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值