【C++】二叉搜索树BST

最新推荐文章于 2024-05-13 21:13:38 发布
最新推荐文章于 2024-05-13 21:13:38 发布
阅读量654 收藏
点赞数 2
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57163217/article/details/130054477
版权

目录

1.二叉搜索树的性质

二叉搜索树又称二叉排序树，具有以下性质:

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

搜索二叉树不允许数据冗余，也就是说其中没有重复的数据。

2.二叉搜索树功能的实现

1.二叉搜索树的框架

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

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

	//功能：插入...
	
private:
	Node* _root = nullptr;
}

2.插入

插入的过程：

  1. 树为空，则直接新增节点，赋值给root指针（所以插入的第一个值就是根）
  2. 树不空，按二叉搜索树性质查找插入位置，插入新节点

注意：二叉搜索树不允许数据冗余，插入相同的数据返回false，用返回值用bool即可。

//插入
bool insert(const K& key)
{
	//空树情况
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;//记录父节点，插入后用以链接插入的数据

	//找到应该插入的叶子结点位置,
	//cur为空时就是该位置的下一个位置（应该插入的位置）
	while (cur)
	{
		if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	//开辟空间初始化要插入的对象
	cur = new Node(key);

	//链接插入的子节点
	if (key > parent->_key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

	return true;
}

3.查找

//查找
bool Find(const K& key)
{
	Node* cur = _root;
	
	while (cur)
	{
		if (key > cur->_key)
		{
			cur = cur->_right;
		}
		else if (key < cur->_key)
		{
			cur = cur->left;
		}
		else
		{
			return true;
		}
		
		return false;
	}
}

4.删除（难点）

删除分为三种情况：

  1. 删除节点为叶子结点
    在这里插入图片描述
  1. 删除节点的左子树为空或右子树为空
    在这里插入图片描述
  1. 删除节点的左右子树都不为空
    在这里插入图片描述

因为左子树的最大节点与右子树的最小节点都可以满足二叉搜索树的性质：

  • 左子树上所有节点的值都小于根节点的值
  • 右子树上所有节点的值都大于根节点的值

代码实现：

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

	while (cur)
	{
		//查找要删除的节点
		if (key > cur->_key)
		{
			cur = cur->_right;
		}
		else if (key < cur->_key)
		{
			cur = cur->_left;
		}
		else//key == cur->_key找到了 ==> 删除
		{
			//0.要删除的节点左右子树都为空
			if (cur->_left == nullptr && cur->_right == nullptr)
			{
				parent->_left = nullptr;
				parent->_right = nullptr;
				delete cur;
			}
			//1.要删除的节点只有右子树，没有左子树
			else if (cur->_left == nullptr)
			{
				//如果要删除的是根，没有父节点，直接更新_root即可
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left == cur->_right;
					}
					else//parent->_right == cur
					{
						parent->_right == cur->_right;
					}
				}
				delete cur;
			}
			//2.要删除的节点只有左子树，没有右子树
			else if (cur->_right == nullptr)
			{
				//如果要删除的是根，没有父节点，直接更新_root即可
				if (cur == _root)
				{
					_root = cur->_lift;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left == cur->_left;
					}
					else//parent->_right == cur
					{
						parent->_right == cur->_left;
					}
				}
				delete cur;
			}
			//3.要删除节点的左右子树都不为空
			else
			{
				//查找 a 或 b ：
				//a.右子树的最小节点-->右子树的最左节点
				//b.左子树的最大节点-->左子树的最右节点

				//查找右子树的最左节点
				Node* Pmin_Right = cur;
				Node* min_Right = cur->_right;

				while (min_Right->_left)
				{
					Pmin_Right = min_Right;
					min_Right = min_Right->_left;
				}

				//将min_Right的值给cur，等于删除了cur，之后释放min_Right即可
				cur->_key = min_Right->_key;

				if (Pmin_Right->_left == min_Right)
				{
					Pmin_Right->_left = min_Right->_right;
				}
				else
				{
					Pmin_Right->_right = min_Right->_right;
				}

				delete min_Right;
			}
		}
	}
}

解析

注意删除节点的时候，都需要记录一下删除节点的父节点，因为需要清除父节点的指针或者需要修改父节点的子树！

1.在树中查找要删除的节点：
在这里插入图片描述

2.删除要分三种情况：
a.要删除的节点为叶子结点，左右子树都为空：
直接删除即可。
在这里插入图片描述

b.要删除的节点只有一个子树：
删除后要托孤，将子树给删除节点的父节点。
注意：删除的节点如果是根节点，父节点为nullptr，要特殊处理，要不然会报错！！
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

c.要删除的节点有两个子树：
删除该节点后，无法托孤给父节点，因为一个节点只能链接两个子节点。
所以要特殊处理：
从该节点的左子树或者右子树中查找一个满足二叉搜索树规则的节点来替换该节点，不就等于删除了该节点吗？
——满足条件的节点：1.左子树的最大节点；2.右子树的最小节点；
那么为什么这两个节点满足条件呢？
——因为这两个节点满足二叉搜索树的规则：左子树的所有节点都小于该节点，右子树的所有节点都大于该节点。
那么这两个节点应该如何找到呢？
——左子树的最小节点：左子树的最靠右一个节点；右子树的最大节点：右子树的最靠左一个节点；

1.这里以右子树的最左节点为例：
（记录其父节点Pmin_Right）
在这里插入图片描述
2.找到对应的节点以后，对其与要删除的节点进行替换：
注意这里要分两种情况：
注意：min_Right已经是右子树的最左节点了，所以它不可能有左子树，也就是只可能存在min_Right->right。

情况一：
这种情况下，Pmin_Right->left == min_Right，可以直接将min_Right->right赋值给Pmin_Right->left。（因为是最左节点，所以只可能是赋值给父节点的左子树）
在这里插入图片描述

情况二：
这种情况下Pmin_Right->left != min_Right，Pmin_Right->right == min_Right，则要将min_Right->right赋值给Pmin_Right->right。（min_Right不可能有左子树，因为它是最左节点）在这里插入图片描述
实现：
在这里插入图片描述

3.二叉搜索树功能的递归实现

1.查找递归实现

//查找递归实现
bool FindR(const K& key)
{
	return _FindR(_root, key);
}

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->_right, key);
	}
	else
	{
		return _FindR(root->_left, key);
	}
}

2.插入递归实现

bool InsertR(const K& key)
{
	return _InsertR(_root, 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//root->_key == key
	{
		return false;
	}
}

递归形式中新建节点的链接问题

解析：递归形式中链接的问题
在插入递归实现的时候，需要新建立节点然后再链接节点，在传root参数的时候，使用传引用传参，就可以做到自动链接新建的节点。
当我们在当前函数栈帧root = new Node(key)创建新的节点时，因为用了引用，其实这里的root就是上一个函数栈帧中的root->right，所以在创建节点完成，返回的时候就等同于完成了链接，其本质就等同于：root->_right = new Node(key);
在这里插入图片描述

3.删除的递归实现

//删除递归实现
bool EraseR(const K& key)
{
	return _EraseR(_root, key);
}

bool _EraseR(Node*& root, const K& key)
{
	if(root == nullptr)
	{
		return false;
	}
	if(root->_key < key)
	{
		return _EraserR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _EraseR(root->_left, key);
	}
	else//key == _key
	{
		//找到了，开始删除
		Node* del = root;
		if(root->_left == nullptr)
		{
			root = root->_right;
		}
		else if(root->_right == nullptr)
		{
			root = root->_left;
		}
		else
		{
			//左右子树都在，找左子树的最大节点/右子树最小节点
			Node* maxleft = root->_left;
			while(maxfile->_right)
			{
				maxleft = maxleft->_right;
			}
			swap(root->_key, maxleft->_key);
			
			return _EraseR(root->_left, key);
		}
		
		delete del;
		return true;
	}
}

解析：
递归删除与普通删除的实现原理相同：
1.要删除的节点为叶子结点，左右子树都为空；
2.要删除的节点只有一个子树；
3.要删除的节点有两个子树；
三种方式删除后都需要delete释放该节点，所以需要用一个del变量来记录要删除的root指针。（删除后root指针置空找不到了）

1.其中1和2两种方式可以用同一种方式解决：
两种情况可以通过下面一段代码完成：
在这里插入图片描述

要删除的节点为叶子结点：
因为root->_left == nullptr，则root = root->_right = nullptr，最后delete del后，即删除完成该节点。
在这里插入图片描述
要删除的节点只有一个子树：
root->_right == nullptr，root = root->_left，直接用其子节点覆盖该节点，最后释放del该节点即可。
在这里插入图片描述

2.要删除的节点有两个子树：
思路与非递归实现删除的思路相同，寻找左子树的最大节点或右子树的最小节点后进行替换然后删除即可。
进而引入递归的思路：
找到左子树的最大节点（右子树的最小节点）后，将其与要删除的节点进行swap交换key，将删除有两个子树节点的问题转化为删除没有子树节点的问题或只有一个子树节点的问题。
交换完成后再次递归进入左子树重新查找key，找到后直接删除即可（问题3转化为1、2情况来删除）。
在这里插入图片描述
在这里插入图片描述

4.二叉搜索树部分默认成员函数实现

1.构造函数

//强制生成默认构造，root声明时候给了缺省值nullptr
BSTree() = default;

解析：
C++11的新特性：default
在函数声明后加=default，将该函数声明为 default 函数，编译器将为显式声明的default函数自动生成函数体。

defaulted函数特性仅适用于类的特殊成员函数，且该特殊成员函数没有默认参数。
defaulted函数既可以在类体里（inline）定义，也可以在类体外定义。

2.拷贝构造函数

//拷贝构造
BSTree(const BSTree<K>& t)
{
	_root = copy(t._root);
}

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

3.析构函数

//析构（递归）
~BSTree()
{
	Destory(_root);
}

void Destory(Node*& root)
{
	if (root == nullptr)
	{
		return;
	}
	//左-右-根
	Destory(root->_left);
	Destory(root->_right);

	delete root;
	root = nullptr;
}

4.赋值运算符重载

//赋值运算符重载
BSTree<K>& operator=(BSTree<K> t)
{
	swap(_root, t._root);
	return *this;
}

5.二叉搜索树实现集合

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;
	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()
		{
			Destory(_root);
		}

		//插入
		bool insert(const K& key)
		{
			//空树情况
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}

			Node* cur = _root;
			Node* parent = nullptr;//记录父节点，插入后用以链接插入的数据

			//找到应该插入的叶子结点位置,
			//cur为空时就是该位置的下一个位置（应该插入的位置）
			while (cur)
			{
				if (key > cur->_key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else//二叉搜索树不能有相同的节点
				{
					return false;
				}
			}
			//开辟空间初始化要插入的对象
			cur = new Node(key);

			//链接插入的子节点
			if (key > parent->_key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}


		//查找
		bool Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					cur = cur->left;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

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

			while (cur)
			{
				//查找要删除的节点
				if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					cur = cur->_left;
				}
				else//key == cur->_key找到了 ==> 删除
				{
					//0.要删除的节点左右子树都为空
					if (cur->_left == nullptr && cur->_right == nullptr)
					{
						parent->_left = nullptr;
						parent->_right = nullptr;
						delete cur;
					}
					//1.要删除的节点只有右子树，没有左子树
					else if (cur->_left == nullptr)
					{
						//如果要删除的是根，没有父节点，直接更新_root即可
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left == cur->_right;
							}
							else//parent->_right == cur
							{
								parent->_right == cur->_right;
							}
						}
						delete cur;
					}
					//2.要删除的节点只有左子树，没有右子树
					else if (cur->_right == nullptr)
					{
						//如果要删除的是根，没有父节点，直接更新_root即可
						if (cur == _root)
						{
							_root = cur->_lift;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left == cur->_left;
							}
							else//parent->_right == cur
							{
								parent->_right == cur->_left;
							}
						}
						delete cur;
					}
					//3.要删除节点的左右子树都不为空
					else
					{
						//查找 a 或 b ：
						//a.右子树的最小节点-->右子树的最左节点
						//b.左子树的最大节点-->左子树的最右节点

						//查找右子树的最左节点
						Node* Pmin_Right = cur;
						Node* min_Right = cur->_right;

						while (min_Right->_left)
						{
							Pmin_Right = min_Right;
							min_Right = min_Right->_left;
						}

						//将min_Right的值给cur，等于删除了cur，之后释放min_Right即可
						cur->_key = min_Right->_key;

						if (Pmin_Right->_left == min_Right)
						{
							Pmin_Right->_left = min_Right->_right;
						}
						else
						{
							Pmin_Right->_right = min_Right->_right;
						}

						delete min_Right;
					}
				}
			}
		}

		//中序遍历
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

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

	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 Destory(Node*& root)
		{
			if (root == nullptr)
			{
				return;
			}
			//左-右-根
			Destory(root->_left);
			Destory(root->_right);

			delete root;
			root = nullptr;
		}

		//中序遍历
		void _InOrder(Node* root)//1.缺省值必须是全局变量或者常量2.访问root需要this指针，this指针也是另一个参数，这里不一定能用
		{
			if (root == nullptr)
			{
				return;
			}

			//左->根->右
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

		//查找递归实现
		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->_right, key);
			}
			else
			{
				return _FindR(root->_left, 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//root->_key == key
			{
				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//key == _key
			{
				//开始删除
				Node* del = root;
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				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;
			}

		}

	private:
		Node* _root = nullptr;
	};
}

5.二叉搜索树增删查改的时间复杂度

时间复杂度为：
O(logN)~O(N)
最优情况下，接近或就是完全二叉树，时间复杂度为O(logN)。
最坏情况下二叉搜索树可能会出现单支树，此时为O(N)。
对二叉搜索树进行优化，控制左右子树的平衡就有了：AVL树和红黑树。
（AVL树与红黑树后续学习）

6.二叉搜索树的应用

K模型(key)

应用于搜索场景：在不在的问题。

结构体中只存在关键码key，关键码就是所需要查找的值。

比如：检查单词是否拼写正确，将词库中的每个单词都作为key构建二叉搜索树，进而检索单词查看是否拼写正确。

KV模型(key-value)

应用于搜索场景：通过一个值查找另一个值的问题。

**每个关键码key，都有与之对应的值value，结构中存在<key, value>的键值对。**通过key来查找value。

比如：中英互译的字典<english, chinese>，就是一对键值对；
或者可以统计单词出现的次数<word, count>，也是一对键值对；

（我们上面实现的是key模型的二叉搜索树）

有够会啦
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ BST
b711183612的专栏
04-10 447
BST(Binary Search Tree) 二叉搜索树又称二叉查找树或二叉排序树，在二叉搜索树中 若任意节点的左子树不空，则左子树上所有节点的值均不大于它的根节点的值； 若任意节点的右子树不空，则右子树上所有的节点的值均不小于它的跟节点的值； 一个n个节点的二叉树，如果二叉树是平衡的，则n个节点的二叉树的高度为log2(n+1),二叉树的查找效率为O(log2n),如果二叉树完全不平衡，则其深度可达到n，查找效率为O(n)，退化为顺序查找。因此为了获得较好的查找性能，就要构造一个平衡的二叉排
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
【C++】二叉搜索树
qq_62939852的博客
04-18 927
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
【c++】二叉搜索树（BST）
最新发布
Quietcoder的博客
05-13 1526
1.二叉搜索树的介绍🔥个人主页Quitecoder🔥c++笔记仓朋友们大家好，本篇文章来到二叉搜索树的内容。
【C++详解】——搜索二叉树
weixin_69519040的博客
04-22 569
本文介绍了搜索二叉树的原理，并且模拟实现了一个搜索二叉树，其中插入、删除、查找功能分别使用了递归和非递归两种实现方式。本文还介绍了两种搜索二叉树的应用场景，根据相应的应用场景将搜索二叉树改造成了KV结构。 本文详细代码链接：https://gitee.com/hrimkn
C++ BST（二叉搜索树）
a130737的专栏
07-19 2905
BST， 是一种完备二叉树。 顾名思义，
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树结构，它的每个节点都包含一个键值（key）、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任意节点，其左子树中的所有节点的键值都...
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
C++二叉搜索树的插入和删除例子
05-29
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的指针和一个指向右子树的指针。在二叉搜索树中，对于任何一个节点，其左子树中的...
【C++】BST树（二叉搜索树）
weixin_56916549的博客
12-17 189
BST树（二叉搜索树）
【C++】二叉搜索树（BST）
taoxing
07-11 780
一.基本介绍 特征： 二叉搜索树，也被称为二叉查找树、有序二叉树或者排序二叉树。 ∙\bullet∙ 一般来说输入的第一个数作为根结点，当继续输入数时，小于根结点的放在根结点左边，大于根结点的放在根结点右边。 ∙\bullet∙ 不只是根结点，每个子节点也符合左小右大的规律。 ∙\bullet∙ 如下图所示，输入数据8、3、10、1、6、14、4、7、13，得到下面的二叉搜索树。 下面我们来介绍BST的构成成分： ∙\bullet∙ 首先我们需要实现两个类：一个是BSTNode类（节点类）、一个为
BST树的建立及各种操作
06-10
建立BST树，并实现 插入 查找 删除等操作，
数据结构（十）、C++ 二叉排序树（BST）
weijianjain的博客
11-23 510
【代码】数据结构（十）、C++ BST二叉搜索树。
BST的C++实现
吉大秦少游
10-04 1151
BST首先是二叉树，对应的二叉树定义和常用操作封装在以下头文件"bintree.h" // 二叉树的头文件 #ifndef bintree_h #define bintree_h #include <iostream> using namespace std; template<class Elem> struct BinNode{ Elem data; ...
二叉排序树（BST）的概念及其基本操作详细教程（C++）
smart_jackli的博客
11-11 1168
二叉排序树的概念及其相关操作详细教程
二分查找树的C++实现 Binary Search Tree（BST）
人生如路
03-13 3339
用C++实现了二叉查找树的 创建 插入 删除 遍历（宽度优先和三种深度优先[前序，中序，后序]） 查找某值 查找最大值和最小值 清空 复制二叉树（深复制） #include #include using namespace std; struct BSTNode { int val; BSTNode *left; BSTNode *right; }; /* ver
c++算法和数据结构之《BST树》
qq_46615150的博客
04-12 456
文章目录一： BST树定义与特征1、BST树的结构设计2、创建一个节点3、BST树的插入 一： BST树定义与特征 BST树，及二叉搜索树（Binary Serch Tree），又叫二叉搜索树或二叉排序树。它可以是一棵空树，也可以是具有以下特征的一棵二叉树。 ①BST树上不存在键值相等的节点 ②若他的左子树不空，则左子树上所有节点的值均小于它的根节点的值 ③若他的右子树不空，则右子树上所有节点的值均大于它的根节点的值 ④任何一个节点的左子树或者右子树都是一棵BST树 ⑤对BST树进行中序遍历，就可以得到一个
[BST的构建][C++实现]
ChessC的博客
03-29 1066
今天前面碰到一题，判定给定的BST是否是合法的，因为BST性质，LDR遍历递增，根据这个来判定即可。但是碰到给定自行构建BST的时候，给定的输入是这样的： 5 1 5 2 3 1 0 0 3 4 5 4 0 0 6 0 0 什么意思呢，第一行为n和root，分别代表总共n个节点，并且root节点为序号root的节点。 之后每一行输入的是三个数，分别为val，left_idx，...
C++最优二叉搜索树详细代码
05-05
最优二叉搜索树（Optimal Binary Search Tree）是一种动态规划的算法，用于在给定一组键和它们的概率时构建最优的二叉搜索树。 下面是 C 语言实现最优二叉搜索树的详细代码： ``` #include #include #define ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值