C++--二叉搜索树

原创 已于 2025-07-06 09:09:09 修改 · 1k 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #c++

于 2025-07-06 09:05:44 首次发布

二叉搜索树

二叉搜索树

1. 二叉搜索树的概念

二叉搜索树又称二叉排序树，他可以是一颗空树，或者是具有以下性质的二叉树：

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值；
  • 它的左右子树也分别为二叉搜索树。
  • 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看用场景定义，后续学习 map/set/multimap/multiset 系列容器底层是二叉搜索树，其中 map/set 不支持插入相等值， multimap/multiset 支持插入相等值。

下面是两个左边是二叉搜索树，右边的不是二叉搜索树。

在这里插入图片描述

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

最优情况下，二叉搜索树为完全二叉树（或者接近完全二叉树），其高度为： l o g 2 N log₂N log2​N

最差情况下，二叉搜索树退化为单支树（或者类似链表），其高度为： N N N

所以综合而言二叉搜索树增加修改时的时间复杂度为： O ( N ) O(N) O(N)

下面是最优情况和最差情况的两种二叉搜索树：

在这里插入图片描述

那么这样的效率显然是无法满足需求的，后面需要继续了解二叉搜索树的变形，平衡二叉搜索树AVL树和红黑树，才会适用在内存中存储和搜索数据。

另外需要说明的是，二分查找可以实现 O ( l o g 2 N ) O(log₂N) O(log2​N)级别的查找效率，但是三分查找有两个缺陷：

  1. 需要存储在支持不带标识符访问的结构中，并且是顺序。
  2. 插入和删除数据效率很低，因为存储在不带标识符的结构中，插入和删除数据一般需要拷贝数据。

这也就表现出了平衡二叉搜索树的价值。

3. 二叉搜索树的操作与实现

下面讲的二叉搜索树的操作均以数组 a 中的数据为例：

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

在这里插入图片描述

首先利用模版定义出一个二叉搜索树的结点：

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

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

3.1 二叉搜索树的插入

插入的具体过程如下：

  1. 树为空，则直接新增结点，赋值给 root 指针。
  2. 树不为空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插入新结点。
  3. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点即可，因为后面涉及可以插入相同值的AVL数可能会利用旋转将插入的左子树旋转到有右子树的位置上。（要注意的是要保持逻辑一致性，插入相等的值不要一会往右走，一会左走）

注意：在遍历查找插入位置的过程中，需要记录父节点的地址，因为需要将新增节点链接到二叉搜索树中。

在这里插入图片描述

在这里插入图片描述

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->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

    //开始插入
	cur = new Node(key);

	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

		return true;
}

3.2 二叉搜索树的查找

查找的具体过程如下：

  1. 从根开始比较，查找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;
}

3.3 二叉搜索树的删除

删除的具体过程如下：

首先查找元素是否在二叉搜索树中，如果不存在，则返回 false 。

如果查找元素存在则分别处理以下四种情况： (假设要删除的节点为 N )

  1. 要删除的节点 N 右孩子为空

    **解决方案：**把 N 节点的父亲对应子节点指针指向空，直接删除 N 节点。（情况1可以当成2或者3处理，效果是一样的）。

  2. 要删除的节点 N 左孩子为空，右孩子结点不为空

    **解决方案：**把 N 节点的父亲对应子节点指针指向 N 的右子节点，直接删除 N 节点。

    在这里插入图片描述

  3. 要删除的节点 N 右孩子为空，左孩子结点不为空

    **解决方案：**把 N 节点的父亲对应子节点指针指向 N 的左子节点，直接删除 N 节点

    在这里插入图片描述

  4. 要删除的节点 N 左右孩子均不为空

    解决方案：无法直接删除 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->_right;
 		}
 		else if (cur->_key > key)
 		{
 			parent = cur;
 			cur = cur->_left;
 		}
        
    	//找到目标值所在节点，执行删除操作
 		else
 		{
            
 			// --- 情况一：待删除节点(cur)的左子树为空 ---
            //注意：这种情况也涵盖左右子树都为空的情况
 			if (cur->_left == nullptr)
 			{
                // 如果 parent 为空，说明要删除的是根节点
 				if (parent == nullptr)
 				{
                     // 直接将根指针指向 cur 的右子节点（即使是 nullptr也没关系）
 					_root = cur->_right;
 				}
 				else// 如果要删除的不是根节点
				{
                    // 判断 cur 是其父节点(parent)的左孩子还是右孩子
 					if (parent->_left == cur)
 						parent->_left = cur->_right;
 					else
						parent->_right = cur->_right;
 				}
 				delete cur;
 				return true;
 			}
            
             // --- 情况二：待删除节点(cur)的右子树为空 ---
 			else if (cur->_right == nullptr)
 			{
                 // 如果 parent 为空，说明要删除的是根节点
 				if (parent == nullptr)
 				{
 					_root = cur->_left;
 				}
 				else// 如果要删除的不是根节点
				{
                    // 判断 cur 是其父节点(parent)的左孩子还是右孩子
 					if (parent->_left == cur)
 						parent->_left = cur->_left;
 					else
                	    parent->_right = cur->_left;
 				}
 				delete cur;
 				return true;
 			}
            
            // --- 情况三：待删除节点(cur)左右子树均不为空 ---
 			else
			{
 				// 2个孩⼦的情况 
 				// 删除情况4，替换法删除 
 				// 假设这⾥我们取右⼦树的最⼩结点作为替代结点去删除 
 				// 这⾥尤其要注意右⼦树的根就是最⼩情况的情况的处理
 				// ⼀定要把cur给rightMinP，否会报错。 
                
                // rightMinP 用来记录最小节点的父节点
 				Node* rightMinP = cur;
                // rightMin 用来寻找并指向右子树中的最小节点，初始指向右子树的根
 				Node* rightMin = cur->_right;
                
                // 循环向左下角移动，直到找到最小节点（即最左侧的节点）
 				while (rightMin->_left)
 				{
 					rightMinP = rightMin;
 					rightMin = rightMin->_left;
 				}
                // 将找到的最小节点(rightMin)的键值，覆盖掉当前要删除节点(cur)的键值
 				cur->_key = rightMin->_key;
                
                // 判断 rightMin 是其父节点(rightMinP)的左孩子还是右孩子
 				if (rightMinP->_left == rightMin)
 					rightMinP->_left = rightMin->_right;
 				else
            	    rightMinP->_right = rightMin->_right;
 				delete rightMin;
 				return true;
 			}
 		}
	 }
	 return false;
}

3.4 模拟实现完整代码

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

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

	//class SearchBinaryTree
	template<class K>
	class BSTree
	{
		typedef BSTNode<K> Node;
	public:
		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->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key);

			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			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->_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;
					}
					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;
					}
					else
					{
						// 找右子树最小节点(最左)替代我的位置
						Node* minRightParent = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							minRightParent = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (minRightParent->_left == minRight)
						{
							minRightParent->_left = minRight->_right;
						}
						else
						{
							minRightParent->_right = minRight->_right;
						}

						delete minRight;
					}

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

		Node* _root = nullptr;
	};
}

4. 二叉搜索树的应用

二叉搜索树主要应用于两种模型 key 模型和 key/value 模型，上面实现的就是 key 模型。

4.1 key的搜索场景

key 模型即只有 key 作为关键码，结构中只需要存储 Key 即可，关键码即为需要搜索到的值，K 模型中，K 的值不可更改；下面以单词拼写来作为 K 模型的一个具体应用场景：

给一个单词word，判断该单词是否拼写正确，可以将 K 的类型定义为 string，然后将英语词库中的所有单词作为 key，构建一颗二叉搜索树，然后在二叉搜索树中对用户写出的每一个单词进行查找，如果找不到，则说明该单词拼写错误。

4.2 key/value的搜索场景

key/value模型即在 key 模型的基础上，给每一个关键码 key 都对应上一个值 value，即<Key, Value>键值对，在 key/value 模型中，key 的值不可更改，该 key 对应的 value 可以更改；key/value 模型在日常生活中非常常见：

比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文 <word, chinese> 就构成一种键值对；

再比如统计每种类型水果的个数，统计成功后，给定水果类型就可快速找到该类型水果的个数，水果类型与其个数就是 <fruit, count> 就构成一种键值对。

上面已经对 key 模型进行了模拟实现，下面对 key 模型的代码进行修改即可修改为 key/value 模型。并实现上面的统计每种类型水果数量的功能：

key /value 模型代码：

namespace key_value
{
	template<class K, class V>
	struct BSTNode
	{
		K _key;
		V _value;
		BSTNode<K, V>* _left;
		BSTNode<K, V>* _right;
		BSTNode(const K& key, const V& value)
			:_key(key)
			, _value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTNode<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;
					}
					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;
					}
					else
					{
						// 找右子树最小节点(最左)替代我的位置
						Node* minRightParent = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							minRightParent = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (minRightParent->_left == minRight)
						{
							minRightParent->_left = minRight->_right;
						}
						else
						{
							minRightParent->_right = minRight->_right;
						}

						delete minRight;
					}

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

		Node* _root = nullptr;
	};

}

使用场景：统计每种类型水果数量

int main()
{
	string arr[] = { "苹果","香蕉","香蕉","西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜","苹果", "香蕉", "苹果", "香蕉","香蕉","香蕉" };
	key_value::BSTree<string, int> countTree;
	for (auto& e : arr)
	{
		//key_value::BSTNode<string, int>* ret = countTree.Find(e);
		auto ret = countTree.Find(e);

		if (ret == nullptr)
		{
			countTree.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();

	return 0;
}

//运行结果：苹果：6 西瓜：3 香蕉：6
C++笔记---二叉搜索树
2302_80372340的博客
09-17 1407
K _key;:_key(key){}public://强制生成默认构造//拷贝构造//析构~BSTree();
C++---二叉搜索树
qq_47406941的博客
05-19 742
一、二叉搜索树的概念 二叉搜索树又称二叉排序树，它是一颗空树或者是具有以下性质的树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树的操作 1、查找 基本思路： 根节点为空，返回false 根节点不为空，比较根节点和要找的值是否相等，相等返回true。 根节点和要找的值不想等时，判断跟节点和要找的值的关系。 如果根节点小于要找到的值，则在右子树找 如果根节点大于要
C++进阶--二叉搜索树
2402_87779153的博客
04-22 775
二叉搜索树定义，重要接口，次要接口
【C++】---二叉搜索树
weixin_75128035的博客
05-29 1866
二叉搜索树又叫二叉排序数，它或者是空树，或者是具有以下性质的二叉树： 比如说：这个数组都可以将它化为二叉搜索树总结：在左子树值比根小，右子树值比根大。 当树走中序遍历时，序列都是有序的。二叉搜索树 的 结构定义： 二、二叉搜索树操作（非递归） 1.二叉搜索树的查找 （非递归） 利用二分查找的方法，借助我们去二叉搜索树中查找节点。 查找的时间复杂度：最坏的情况，就是查找高度（h=logN）次，就可以判断一个值在不在节点里面。查找的思路： （2）中序遍历 由于根节点_root是私有成员变量，如果在main函数
C++进阶--＞二叉搜索树
2301_80475151的博客
10-28 743
二叉搜索树的概念、性能、实现、还有key/value二叉搜索树的实现
c++进阶--二叉搜索树
2302_79606537的博客
03-04 822
大家好，今天我们来学习在c++中更深奥的数据结构，二叉搜索树。1. ⼆叉搜索树的概念⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:1. 若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值2. 若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值3. 它的左右⼦树也分别为⼆叉搜索树。
C++进阶----二叉搜索树
weixin_63219391的博客
05-06 1025
二叉搜索树
C++ - AVL (二叉平衡搜索树) 解析
m0_74506452的博客
12-01 708
上一篇博客中讲解了二叉搜索树:我们了解到, 二叉搜索树的最坏时间复杂度为 O(N). (插入的顺序是有序的)所以在实际中, 直接使用二叉搜索树的情况很少.那么为了解决二叉搜索树这种最坏情况, 就有大佬提出了 AVL 树.AVL 树又称为 二叉平衡搜索树, 可以看到, 多了两个字 "平衡".那么平衡是什么意思:之前的二叉搜索树在插入顺序是有序的情况下, 会形成一个链表的结构, 从而导致查找的时间复杂度变为 O(N).
【C++】二叉搜索树
春风不语。
10-01 1331
本篇到这里就结束了，主要讲了二叉搜索树的基本概念以及实现逻辑，希望对大家有所帮助，祝生活愉快，我们下篇再见！
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
【二叉树进阶】--- 二叉搜索树转双向链表 && 最近公共祖先
2301_79448270的博客
08-14 1962
不同的是，我们需要记录前驱节点prev，ptail->next = node,此时的node就是我们中序遍历的当前访问节点，此时ptail需要更新成node(当前访问节点),prev就是上一个按中序被访问节点，所以我们需要在更新ptail之前记录prev，同时更新好前驱和后继指针的指向。归根结底，找公共祖先也就是找公共节点，如果我们能求出两个节点的祖先路径，就能转化为链表相交问题了。题目要求链表中的节点是排好序的，因此结合二叉搜索树的性质(二叉搜索树中序遍历出来是有序的)，我们可以。
[C++]---二叉搜索树简单实现(查找，插入，删除)
夜微雨的博客
02-28 1508
目录 二叉搜索树概念及特点 1.特点 二叉搜索树的简单操作 1.查找操作 2.插入操作 3.删除操作 二叉搜索树的性能分析 二叉搜索树概念及特点 1.特点 二叉搜索树又称二叉排序树，它可能是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别...
HarmonyOS NEXT仓颉开发语言实战案例：小而美的旅行App
youlanjihua的博客
06-29 391
#HarmonyOS语言##仓颉##休闲娱乐#
C++ 变长参数、折叠表达式
zzzsss123333的博客
07-05 775
含义：(((init op pack1) op pack2) …含义：(((init op pack1) op pack2) …(packN op init)))含义：((pack1 op pack2) op pack3) …二元右折叠：(arg1 << (arg2 << (arg3 << init)))一元左折叠：(((arg1 + arg2) + arg3) + …二元左折叠：(((100 - arg1) - arg2) - …二元左折叠：(((100 - arg1) - arg2) - …
华为OD机试 2025B卷 - 字符串加密 (C++ & Python & JAVA & JS & C语言)
最新发布
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
07-07 18
华为OD机试 2025B卷 字符串加密 提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解
QML与C++交互之创建自定义对象
cpp_learner的博客
07-06 778
本文介绍了在QML中通过C++定义全局对象的方法。主要包含：1. 使用QQmlApplicationEngine的rootContext()获取全局上下文，通过setContextProperty()设置全局变量；2. 自定义C++类继承QObject并使用Q_PROPERTY宏暴露属性，通过qmlRegisterType()注册后可在QML中使用；3. 详细解释了Q_PROPERTY的参数含义和NOTIFY信号的作用机制，说明冒号赋值(:)会建立属性绑定关系，而等号赋值(=)不会。
C++:string类（2）
2401_87353862的博客
07-04 85
以上代码演示 C++ string 三类追加操作： += 灵活拼接字符串/字符， push_back 专一追加单个字符， append 针对性扩展字符串。通过 test01 函数里的 s1 s2 s3 实例，直观展现不同接口的用法差异，看输出就能秒懂它们在字符串扩展时的具体表现。（注：本文承接《C++:string类（1）》的内容）1string类对象的修改操作。一.string类的常用接口。1.2字符串的增删改。
C++实现的二叉搜索树源码解析
二叉搜索树的C++实现可以充分利用面向对象的特性，通过构造函数、析构函数、成员函数等，来实现树的构建、数据的添加、查找和删除等操作。 在具体实现上，二叉搜索树的每个节点通常包含三个基本的成员：一个存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值