秒懂C++之二叉搜索树

于 2024-08-13 01:10:24 发布
阅读量384 收藏 7
点赞数 10
分类专栏： c++ 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fax_player/article/details/141141323
版权

fe594ea5bf754ddbb223a54d8fb1e7bc.gif

目录

前言

一. 二叉搜索树实现

1.1 二叉搜索树概念

1.2 二叉搜索树的查找

非递归：

递归;

1.3 二叉搜索树的插入

非递归：

递归：

1.4 二叉搜索树的删除

非递归：

递归：

1.5 拷贝构造

1.6 运算符=

1.7 析构函数

二.KV模型二叉树

三.全部代码

前言

学习二叉搜索树是为了后面的map与set作铺垫有助于更好理解其特性~

一. 二叉搜索树实现

1.1 二叉搜索树概念

  二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树  

通俗来讲就是中序遍历是排好序的~

接下来我们就以该图进行二叉树的实现原理~ 

1.2 二叉搜索树的查找

二叉树的查找很简单，我们只需要利用二叉搜索树的特性即可：

我们要找的值比8小，则去左子树找（因为左子树都是比8小的）。比3大则去右子树找，比6大继续去右子树找。直到找到或为空为止~

非递归：

template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	Node* _left;
	Node* _right;
	K _key;
    BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}

};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//二叉树查找
	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;
	}

private:
	Node* _root = nullptr;
};

递归;

bool FindR(const K& key)
	{
		return  _FindR(_root, key);
	}
	//寻找递归版本
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (key > root->_key)
		{
			return _FindR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}

	}

1.3 二叉搜索树的插入

插入我们只需要继续查找的套路就行了，只不过在最后是为空节点的时候插入~

非递归：

template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	Node* _left;
	Node* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}

};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//二叉树查找
	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 Insert(const K& key)
	{

		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		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指向空节点时开始插入
		cur = new Node(key);
		//如果父节点的左节点存在则插入其右节点
		if (key>parent->_key)
		{
			parent->_right = cur;
		}
		if (key < parent->_key)
		{
			parent->_left = cur;
		}
		return true;
	}
	//中序遍历
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}


	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

private:
	Node* _root = nullptr;
};

ps:插入有几点细节需要注意

  • 开始如果是空树需要特殊判断
  • 最后cur找到空节点后还需要与父节点链接起来，所以记得记录cur的父节点
  • 我们编写中序遍历时在类外是取不到_root的，所以需要套一层外壳~递归都需要套一层壳~

递归：

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

	}

ps:不用去担心插入后的节点链接问题~引用帮我们解决了一切，这也是引用在递归中很精妙的写法~

 

1.4 二叉搜索树的删除

非递归：

删除的情况很复杂，我们先对删除划分情况

  • 要删除的结点无孩子结点或只有一个孩子节点
  • 要删除的结点有左、右孩子结点

我们先来重点讨论第一种划分：

除了考虑寻常节点外，我们还得考虑删除根节点的情况~

最后再来讨论第二种划分：

这里解释一下，因为rightmin已经是最左节点，那么其左孩子一定是空节点，只要跟着这个线索就可以找到rightmin节点了~本质其实就是找到可以替换的节点，然后数据交换，最后删除节点~

至此所有情况全都说明完毕，其实只是在两种划分考虑正常节点的基础上再考虑根节点的情况而言

bool Erase(const K& key)
	{
		if (_root == nullptr)
		{
			return false;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			//找到目标节点
			else
			{
				//开始划分情况
				//目标节点没有左节点，有右节点
				if (cur->_left == nullptr)
				{	//如果删除的是根节点
					if (cur == _root)
					{
						cur = _root->_right;
					}
					//正常节点
					else
					{
						//看删除节点是父节点的左还是右
						if (cur == parent->_right)
						{
							//让父节点链接删除节点的右节点
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				//目标节点有左节点，没有右节点
				else if (cur->_right == nullptr)
				{
					//如果删除的是根节点
					if (cur == _root)
					{
						_root = _root->_left;
					}
					//正常节点
					else
					{
						//看删除节点是父节点的左还是右
						if (cur == parent->_right)
						{
							//让父节点链接删除节点的左节点
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
					return true;
				}
				//如果目标节点有两个孩子节点
				//替换法
				else
				{
					Node* rightminparent = cur;
					Node* rightmin = cur->_right;
					while (rightmin->_left)
					{
						rightminparent = rightmin;
						rightmin = rightmin->_left;
					}
					cur->_key = rightmin->_key;
					if (rightmin == rightminparent->_left)
					{
						rightminparent->_left = rightmin->_right;
					}
					else
					{
						rightminparent->_right = rightmin->_right;
					}
					delete rightmin;
					return true;
				}
				
			}
		}
		return false;

	}

 

递归：

	//删除递归版本
	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 _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		//说明找到要删除的节点了
		else
		{
			Node* del = root;
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

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

				return _EraseR(root->_right, key);
			}

			delete del;
			return true;
		}
	}

这里同样用引用解决了删除节点后剩下的链接问题~

1.5 拷贝构造

// 写了拷贝构造就不会有默认构造了 强制生成默认构造
	BSTree() = default;

//拷贝构造
	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;
	}

 

1.6 运算符=

//赋值 现代写法
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

1.7 析构函数

 

~BSTree()
	{
		Destroy(_root);
	}

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

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

析构函数正常用后续遍历删除节点即可~ 

二.KV模型二叉树

我们上述实现的就是K模型二叉树，而kv模型二叉树就是多传了一个value值而已~

拿商场停车场作类比~

  • 进入商场停车场（记录k值车牌号，记录v值停车时间）
  • 离开商场停车场（查看k值车牌号，查看v值停车时间，根据时间收费）

这里我们用kv模型来实现英汉词典

英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文就构成一种键值对； 
namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;

		Node* _left;
		Node* _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:
		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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

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

						delete cur;
						return true;
					}
					else
					{
						// 替换法
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;

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

其实kv模型也就是在插入的时候添加了value值而已，然后我们通过查找key值可以映射对应的value值。

三.全部代码

//BinarySearchTree.h
#pragma once

template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	Node* _left;
	Node* _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()
	{
		Destroy(_root);
	}

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

		Destroy(root->_left);
		Destroy(root->_right);
		delete 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;
	}

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}
	//寻找递归版本
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (key > root->_key)
		{
			return _FindR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			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 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 (key > root->_key)
		{
			return _InsertR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}

	}

	  
	//二叉树插入
	//bool Insert(const K& key)
	//{

	//	if (_root == nullptr)
	//	{
	//		_root = new Node(key);
	//		return true;
	//	}
	//	Node* cur = _root;
	//	Node* parent = nullptr;
	//	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指向空节点时开始插入
	//	cur = new Node(key);
	//	//如果父节点的左节点存在则插入其右节点
	//	if (key>parent->_key)
	//	{
	//		parent->_right = cur;
	//	}
	//	if (key < parent->_key)
	//	{
	//		parent->_left = cur;
	//	}
	//	return true;
	//}
	//中序遍历
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}

	//中序遍历
	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
	//删除递归版本
	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 _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		//说明找到要删除的节点了
		else
		{
			Node* del = root;
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

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

				return _EraseR(root->_right, key);
			}

			delete del;
			return true;
		}
	}
	
	//bool Erase(const K& key)
	//{
	//	if (_root == nullptr)
	//	{
	//		return false;
	//	}
	//	Node* parent = nullptr;
	//	Node* cur = _root;
	//	while (cur)
	//	{
	//		if (key > cur->_key)
	//		{
	//			parent = cur;
	//			cur = cur->_right;
	//		}
	//		else if (key < cur->_key)
	//		{
	//			parent = cur;
	//			cur = cur->_left;
	//		}
	//		//找到目标节点
	//		else
	//		{
	//			//开始划分情况
	//			//目标节点没有左节点，有右节点
	//			if (cur->_left == nullptr)
	//			{	//如果删除的是根节点
	//				if (cur == _root)
	//				{
	//					cur = _root->_right;
	//				}
	//				//正常节点
	//				else
	//				{
	//					//看删除节点是父节点的左还是右
	//					if (cur == parent->_right)
	//					{
	//						//让父节点链接删除节点的右节点
	//						parent->_right = cur->_right;
	//					}
	//					else
	//					{
	//						parent->_left = cur->_right;
	//					}
	//				}
	//				delete cur;
	//				return true;
	//			}
	//			//目标节点有左节点，没有右节点
	//			else if (cur->_right == nullptr)
	//			{
	//				//如果删除的是根节点
	//				if (cur == _root)
	//				{
	//					_root = _root->_left;
	//				}
	//				//正常节点
	//				else
	//				{
	//					//看删除节点是父节点的左还是右
	//					if (cur == parent->_right)
	//					{
	//						//让父节点链接删除节点的左节点
	//						parent->_right = cur->_left;
	//					}
	//					else
	//					{
	//						parent->_left = cur->_left;
	//					}
	//				}
	//				delete cur;
	//				return true;
	//			}
	//			//如果目标节点有两个孩子节点
	//			//替换法
	//			else
	//			{
	//				Node* rightminparent = cur;
	//				Node* rightmin = cur->_right;
	//				while (rightmin->_left)
	//				{
	//					rightminparent = rightmin;
	//					rightmin = rightmin->_left;
	//				}
	//				cur->_key = rightmin->_key;
	//				if (rightmin == rightminparent->_left)
	//				{
	//					rightminparent->_left = rightmin->_right;
	//				}
	//				else
	//				{
	//					rightminparent->_right = rightmin->_right;
	//				}
	//				delete rightmin;
	//				return true;
	//			}
	//			
	//		}
	//	}
	//	return false;

	//}

private:
	Node* _root = nullptr;
};




namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;

		Node* _left;
		Node* _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:
		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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

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

						delete cur;
						return true;
					}
					else
					{
						// 替换法
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMin == rightMinParent->_left)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;

						delete rightMin;
						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;
	};
}
//test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>

using namespace std;

#include "BinarySearchTree.h"


//int main()
//{
//	/*BSTree<int> t;
//	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
//	
//	for (auto e : a)
//	{
//		t.InsertR(e);
//	}
//	t.Inorder();
//
//
//	BSTree<int> t1;
//	t1 = t;
//	t1.Inorder();
//	t1.Inorder();*/
//
//	/*BSTree<int> t1(t);
//	t1.Inorder();*/
//	/*for (auto e : a)
//	{
//		t.EraseR(e);
//		t.Inorder();
//	}*/
//
//	//BSTree<int> t;
//
//	/*t.Inorder();
//	BSTree<int> t;
//
//
//	cout << t.Find(8) << endl;
//	cout << t.Find(14) << endl;
//	cout << t.Find(15) << endl;*/
//
//
//	key_value::BSTree<string,string> t;
//
//
//
//
//	return 0;
//
//}

int main()
{
	key_value::BSTree<string, string> dict;
	dict.Insert("apple", "苹果");
	dict.Insert("keep", "坚持");
	dict.Insert("good", "好棒");
	dict.Insert("sleep", "睡觉");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "找不到" << endl;
		}
	}

	return 0;
}

玛丽亚后
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
C++ 之二叉搜索树
qq_74732628的博客
04-24 618
详解c++ 二叉搜索树的实现以及功能
【C++】二叉搜索树
qq_62939852的博客
04-18 938
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为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++——二叉搜索树
weixin_49449676的博客
11-30 1928
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
【 C++ 】二叉搜索树
bit_zyx的博客
09-03 996
目录 1、二叉搜索树的概念 2、二叉搜索树的实现 ①、结点类 ②、二叉搜索树的类 2.1、默认成员函数 构造函数 拷贝构造函数 赋值运算符重载函数 析构函数 2.2、中序遍历 2.3、Insert插入函数 ............
C++二叉搜索树
默的博客
05-05 585
C++二叉搜索树1、概念2、操作2.1增加（插入）2.2删除2.3查找2.4修改3、 二叉搜索树的性能分析4、模拟实现代码 1、概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值； 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值； 它的左右子树也分别为二叉搜索树。 2、操作 2.1增加（插入） 树为空，直接插入，返回true； 树不为空，判断根节点数据大小，根数据大往左边找，否则往右边找，找到返回true；
C++: 二叉搜索树及实现
2301_79490289的博客
05-27 623
由于使用递归，所以需要取root的引用，参数就要给root，而在类外是没有办法获取作为私有的root的，因此只能把实现的细节写在private里。
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 1020
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3676
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
C++ —— 二叉搜索树
原来45的博客
09-17 1099
二叉搜索树概念 二叉搜索树操作 1. 二叉搜索树的查找 2.二叉搜索树的插入 3. 二叉搜索树的删除 二叉搜索树的应用 1. K模型 2. KV模型 二叉搜索树的性能分析 二叉搜索树的实现（K&&KV）和测试（KV）
C++之二叉搜索树详解
be_a_struggler的博客
11-20 1244
C++二叉搜索树实现，二叉搜索树的概念，二叉搜索树的插入，查找，删除的递归与非递归实现，二叉搜索树的构造函数，拷贝构造函数，析构函数，二叉搜索树的应用，二叉搜索树的性能分析
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
单链表-数据结构
qq_31804097的博客
08-07 209
【代码】单链表、双向带头循环链表-数据结构。
常见8种数据结构
qq_43575301的博客
08-08 1866
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 433
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
基础算法模板
最新发布
2301_79235379的博客
08-08 417
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
C++STL 二叉搜索树
09-06
C++ STL中没有直接提供二叉搜索树的实现，但STL中有一些关于树的容器，比如set和map，它们底层的实现就是基于红黑树（一种平衡二叉搜索树）的。你可以使用这些容器来实现二叉搜索树的功能。关于二叉搜索树的一些知识，比如二叉树的遍历、迭代、线索二叉树、堆、Huffman编码、AVL树等都可以在STL中找到相应的实现。 二叉搜索树的查找可以通过比较根节点的值和目标值的大小来判断是往左子树还是往右子树查找，并重复这个过程直到找到目标值或者遍历到叶子节点为止。常规实现使用循环来实现查找，递归实现使用递归函数来查找。 二叉搜索树的插入操作也可以通过递归或循环来实现，根据目标值和当前节点的值的大小关系来决定是往左子树还是往右子树插入新节点。 STL中的二叉搜索树容器如set和map提供了插入、删除和查找等功能，并且保持了二叉搜索树的性质。你可以使用这些容器来处理二叉搜索树相关的操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [C++ STL 数据结构 树](https://download.csdn.net/download/xinxipan/3008948)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [【C++ STL】-- 二叉搜索树](https://blog.csdn.net/weixin_64609308/article/details/128018280)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值