【C++】二叉搜索树

已于 2024-09-26 11:54:31 修改
阅读量1k 收藏 101
点赞数 104
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-09-18 23:31:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2203_76003626/article/details/142255262
版权

二叉搜索树

1.二叉搜索树的概念

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

  1. 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值。

  2. 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值。

  3. 它的左右子树也分别为⼆叉搜索树。

⼆叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，map / set / multimap / multiset 系列容器底层就是⼆叉搜索树，其中map/set不支持插入相等
值，multimap/multiset支持插入相等值。

在这里插入图片描述

2.二叉搜索树的性能分析

最优情况下，二叉搜索树为完全二叉树(或者接近完全⼆叉树)，其高度为：O(logN)
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其高度为：O(N)
所以综合而言二叉搜索树增删查改时间复杂度为：O(N)

在这里插入图片描述

那么这样的效率显然是无法满足我们需求的，所以有了⼆叉搜索树的变形，平衡⼆叉搜索树。
平衡⼆叉搜索树：AVL树和红黑树
平衡多叉搜索树：B树系列（B+树…）

它们适用于我们在内存中存储和搜索数据，另外需要说明的是，⼆分查找也可以实现O(logN) 级别的查找效率，但是⼆分查找有两大缺陷：

  1. 需要存储在支持下标随机访问的结构中，并且有序。
  2. 插入和删除数据效率很低，因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据。

这里也就体现出了平衡⼆叉搜索树的价值。

3.二叉搜索树的实现

1.二叉搜索树的结构

  1. 准备树的节点（存放两个自己类型的指针找到左右孩子 + 保存某个类型的数据）
  2. 准备二叉搜索树：存放根节点。
  3. 这里实现的是不能含有重复的数据。
namespace xzy
{
	template<class K>
	struct BSNode
	{
		BSNode<K>* _left;
		BSNode<K>* _right;
		K _key;

		BSNode(const K& key = K())
			:_left(nullptr)
			,_right(nullptr)
			,_key(key)
		{}
	};

	template<class K>
	class BSTree
	{
	public:
		//以下两种功能一样：都是取别名
		//typedef BSNode<K> Node;
		using Node = BSNode<K>;
		
	private:
		Node* _root = nullptr; //给出缺省值
	};
}

2.二叉搜索树的插入

插入的具体过程如下：

  1. 树为空：则直接新增结点，赋值给root指针。
  2. 树不空：按⼆叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插入新结点。
  3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。（要注意的是要保持逻辑⼀致性，插入相等的值不要一会往右走，一会往左走）

在这里插入图片描述

在这里插入图片描述

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->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false; //相等，则无法插入
		}
	}

	//找到了要插入的位置 + 它的父亲节点; 然后判断左右孩子
	Node* newnode = new Node(key);
	if (parent->_key > key)
	{
		parent->_left = newnode;
	}
	else if (parent->_key < key)
	{
		parent->_right = newnode;
	}
	return true;
}

3.二叉搜索树的查找

  1. 从根开始比较，查找x，x比根的值大则往右边走查找，x比根值小则往左边走查找。

  2. 最多查找高度次，走到到空，还没找到，这个值不存在。

  3. 如果不支持插入相等的值，找到x即可返回。

  4. 如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x。如下图，查找3，要找到1的右孩子的那个3返回。

在这里插入图片描述

//循环
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; //未找到
}

//递归
public:
	bool Find(const K& key)
	{
		return _Find(_root, key);
	}
	
private:
	bool _Find(Node* _root, const K& key)
	{
		if (_root == nullptr)
			return false;

		bool ret1 = false;
		bool ret2 = false;

		if (_root->_key == key)
		{
			return true;
		}
		else if (_root->_key < key)
		{
			ret1 = Find(_root->_right, key);
		}
		else
		{
			ret2 = Find(_root->_left, key);
		}
		return ret1 || ret2;
	}

4.二叉搜索树的删除

首先查找元素是否在⼆叉搜索树中，如果不存在，则返回false。如果查找元素存在则分以下四种情况分别处理：

  1. 要删除结点N左右孩子均为空。
  2. 要删除的结点N左孩子为空，右孩子结点不为空。
  3. 要删除的结点N右孩子为空，左孩子结点不为空。
  4. 要删除的结点N左右孩子结点均不为空。

对应以上四种情况的解决方案：

  1. 把N结点的父亲对应孩子指针指向空，直接删除N结点（情况1可以当成情况2或者情况3处理，效果是一样的）

在这里插入图片描述

  1. 把N结点的父亲对应孩子指针指向N的右孩子，直接删除N结点。

在这里插入图片描述

  1. 把N结点的父亲对应孩子指针指向N的左孩子，直接删除N结点。

在这里插入图片描述

  1. 无法直接删除N结点，因为N的两个孩子无处安放，可以用替换法删除。找N左子树的值最大结点R（最右节点）或者N右子树的值最小结点R（最左节点）替代N，因为这两个结点中任意一个，放到N的位置，都满足二叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转而变成删除R结点，R结点又符合情况2或情况3，可以直接删除。

在这里插入图片描述

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;

	//找要删除的节点
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//找到了，开始删除操作：删除cur，cur的父亲节点是parent

			//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* replace = cur->_left;
				Node* replaceParent = cur;

				while (replace->_right)
				{
					replaceParent = replace;
					replace = replace->_right;
				}

				cur->_key = replace->_key; //值覆盖

				//要删除的replace节点的孩子最多只有一个，复用情况1/2
				if (replaceParent->_left == replace)
				{
					replaceParent->_left = replace->_left;
				}
				else
				{
					replaceParent->_right = replace->_left;
				}

				delete replace;
			}

			return true;
		}
	}

	return false; //没有要删除的数据
}

5.二叉搜索树的中序遍历

  1. 由于二叉搜索树的性质，左子树小于根，根又小于右子树，那么它的中序遍历就可以得到一个有序的数据
  2. 但是由于要传入根节点，而外面是访问不到根节点的，可以封装另一个接口，如下：
public:
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

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

int main()
{
	vector<int> v = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

	xzy::BSTree<int> t;
	for (auto& e : v)
	{
		t.Insert(e);
	}

	t.InOrder(); //输出: 1 3 4 6 7 8 10 13 14

	return 0;
}

6.默认构造

//强制生成默认构造
BSTree() = default;

7.拷贝构造

前序遍历构造二叉搜索树

public:
	BSTree(const BSTree& t)
	{
		_root = Copy(t._root);
	}
	
private:
	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;
	}

8.赋值重载

现代写法：利用传值传参+拷贝构造

BSTree& operator=(BSTree tmp)
{
	swap(_root, tmp._root);
	
	return *this;
}

9.析构函数

后序遍历析构二叉搜索树

public:
	~BSTree()
	{
		Destory(_root);
	}
	
private:
	void Destory(Node* _root)
	{
		if (_root == nullptr)
			return;

		Destory(_root->_left);
		Destory(_root->_right);
		delete _root;
	}

4.二叉搜索树key和key/value使用场景

1.key搜索场景（set容器）

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。key的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，修改key破坏搜索树结构了。

场景1：小区无人值守车库，小区车库买了车位的业主车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。

场景2：检查一篇英文文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在⼆叉搜索树中，不在则波浪线标红提示。

在这里插入图片描述

2.key/value搜索场景（map容器）

每一个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中（结点）除了需要存储key还要存储对应的value，增/删/查还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。key/value的搜索场景实现的⼆叉树搜索树支持修改，但是不支持修改key，修改key破坏搜索树结构了，可以修改value。

场景1：简单中英互译字典，树的结构中（结点）存储key（英文）和vlaue（中文），搜索时输入英文，则同时查找到了英文对应的中文。

场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，用当前时间 - 入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。

场景3：统计一篇文章中单词出现的次数，读取一个单词，查找单词是否存在，不存在这个说明第一次出现（单词，1），单词存在，则++单词对应的次数。

在这里插入图片描述

5.key二叉搜索树代码

namespace key
{
	template<class K>
	struct BSNode
	{
		BSNode<K>* _left;
		BSNode<K>* _right;
		K _key;

		BSNode(const K& key = K())
			:_left(nullptr)
			,_right(nullptr)
			,_key(key)
		{}
	};

	template<class K>
	class BSTree
	{
	public:
		//以下两种功能一样：都是取别名
		//typedef BSNode<K> Node;
		using Node = BSNode<K>;

		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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return false; //相等，则无法插入
				}
			}

			//找到了要插入的位置 + 它的父亲节点; 然后判断左右孩子
			Node* newnode = new Node(key);
			if (parent->_key > key)
			{
				parent->_left = newnode;
			}
			else if (parent->_key < key)
			{
				parent->_right = newnode;
			}
			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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//找到了，开始删除操作：删除cur，cur的父亲节点是parent

					//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* replace = cur->_left;
						Node* replaceParent = cur;

						while (replace->_right)
						{
							replaceParent = replace;
							replace = replace->_right;
						}

						cur->_key = replace->_key; //值覆盖

						//要删除的replace节点的孩子最多只有一个，复用情况1/2
						if (replaceParent->_left == replace)
						{
							replaceParent->_left = replace->_left;
						}
						else
						{
							replaceParent->_right = replace->_left;
						}

						delete replace;
					}

					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 << " ";
			_InOrder(_root->_right);
		}

	private:
		Node* _root = nullptr;
	};
}

int main()
{
	vector<int> v = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };

	key::BSTree<int> t;
	for (auto& e : v)
	{
		t.Insert(e);
	}

	for (auto& e : v)
	{
		t.Erase(e);
		t.InOrder();
	}

	return 0;
}

6.key/value二叉搜索树代码

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

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

	template<class K, class V>
	class BSTree
	{
	public:
		//以下两种功能一样：都是取别名
		//typedef BSNode<K> Node;
		using Node = BSNode<K, V>;

		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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					return false; //相等，则无法插入
				}
			}

			//找到了要插入的位置 + 它的父亲节点; 然后判断左右孩子
			Node* newnode = new Node(key, value);
			if (parent->_key > key)
			{
				parent->_left = newnode;
			}
			else if (parent->_key < key)
			{
				parent->_right = newnode;
			}
			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->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
				{
					//找到了，开始删除操作：删除cur，cur的父亲节点是parent

					//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* replace = cur->_left;
						Node* replaceParent = cur;

						while (replace->_right)
						{
							replaceParent = replace;
							replace = replace->_right;
						}

						cur->_key = replace->_key; //值覆盖

						//要删除的replace节点的孩子最多只有一个，复用情况1/2
						if (replaceParent->_left == replace)
						{
							replaceParent->_left = replace->_left;
						}
						else
						{
							replaceParent->_right = replace->_left;
						}

						delete replace;
					}

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

int test01()
{
	key_value::BSTree<string, string> dict;

	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.Insert("insert", "插入");
	dict.Insert("string", "字符串");

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

	return 0;
}

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

	return 0;
}

int main()
{
	test01();
	test02();

	return 0;
}

7.经典二叉树OJ题

清风~徐~来
关注
专栏目录
C++复习之路（五）——STL标准模板库
iotflh的博客
01-23 601
一、STL概述。 1、基本概念 STL（Standard Template Library，标准模板库）是惠普实验室开发的一系列软件统称。 STL从广义上讲分为三类：algorithm（算法）、container（容器）和 iterator（迭代器）。容器和算法可以通过迭代器无缝地连接。几乎所有代码都采用了模板类和模板函数的方式。相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。在...
【C++】二叉树
AliceK1008的博客
07-04 484
在计算机科学中，二叉树是每个节点最多有两个子树的树结构。二叉树可以为空树，通常子树被称为”左子树“和”右子树“ 比如下图就是一棵二叉树 二叉树的每个节点最多有两棵子树（不存在度大于2的节点），二叉树的子树有左右之分，次序不能颠倒 二叉树的第i层，最多有2i−12^{i-1}2i−1个结点 深度为k的二叉树，最多有2k−12^k-12k−1个结点 对于任何一颗二叉树，如果其叶结点数为n0n0n0，度为2的节点数为n2n2n2，则n0=n2+1n0=n2+1n0=n2+1 对于最后一个结论可以这么理解，当我们
C++ 数据结构——二叉树（最最最最最实用的二叉树教程）
最新发布
Ahjol171的博客
09-04 1273
本文介绍了基础二叉树的常见操作与创建，包含代码实现以及其代码逻辑
c++二叉树
weixin_34050005的博客
10-17 77
1 #ifndef _TREE_H_ 2 #define _TREE_H_ 3 //此类用shared_ptr来管理节点内存，所以要包含<memory>头文件,不需要手动释放内存 4 #include <memory> 5 #include <iostream> 6 7 using namespace std; 8 ...
C/C++ 二叉树
Sonui的博客
11-19 187
查找二叉树有一个特性 对于所有的节点，都满足左子树上的所有节点都比自己的小，而右子树上的所有节点都比自己大 ————《挑战程序设计竞赛第二版》P78 #include <iostream> #include <stdlib.h> using namespace std; typedef struct TreeNode { int data; struct TreeNode *LT, *RT; }TreeNode, *TreeList; //创建一个叶子节点
二叉树C++
qq_41951198的博客
03-10 211
一、结果显示 二、BinaryTree.h #include &lt;iostream&gt; using namespace std; class BinaryTree { public: struct BinaryNode { int data; BinaryNode *leftChild; BinaryNo...
C++中的二叉树
qq_28236097的博客
09-20 367
二叉树
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
C++二叉搜索树的插入和删除例子
05-29
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任何一个节点，其左子树中的...
C++二叉搜索树
weixin_63246738的博客
07-30 366
C++二叉搜索树
C++之二叉树
weixin_44367041的博客
07-01 121
#include <iostream> using namespace std; template <class T> class LinkedNode { template <class T> friend class LinkedBinTree; public: LinkedNode() { m_pLeftChild = m_pRightChild = NULL; } LinkedNode(const T& x) { m_pLeftChi
C++——二叉树
m0_74515566的博客
02-10 699
先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。
c++的二叉树
热门推荐
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
C++二叉树
zhaochengyuan的专栏
08-11 964
二叉树之小球下落 问题描述： 有一棵二叉树，最大深度为D，且所有的叶子的深度都相同，所有的结点从上到下，从左到右编号为1,2,3.....2^D-1。 在结点1处放一个小球，他会往下落。每个结点上都有一个开关，初始全部关闭，当每次小球落到一个开关上时，它的状态改变。当小球到达一个结点时，如果该节点上开关关闭，则往左走，否则往右走，直到走到子叶结点。
c++二叉搜索树的创建
11-13
以下是C++中创建二叉搜索树的示例代码： ```c++ #include <iostream> using namespace std; // 定义二叉搜索树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 插入节点函数 TreeNode* insertNode(TreeNode* root, int val) { if (root == NULL) { return new TreeNode(val); } if (val < root->val) { root->left = insertNode(root->left, val); } else { root->right = insertNode(root->right, val); } return root; } // 创建二叉搜索树函数 TreeNode* createBST(int arr[], int n) { TreeNode* root = NULL; for (int i = 0; i < n; i++) { root = insertNode(root, arr[i]); } return root; } // 中序遍历函数 void inorderTraversal(TreeNode* root) { if (root == NULL) { return; } inorderTraversal(root->left); cout << root->val << " "; inorderTraversal(root->right); } int main() { int arr[] = {5, 3, 7, 1, 4, 6, 8}; int n = sizeof(arr) / sizeof(arr[0]); TreeNode* root = createBST(arr, n); inorderTraversal(root); // 输出：1 3 4 5 6 7 8 return 0; } ```
评论 75
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值