C++ 高阶数据结构：二叉搜索树（BST）万字详解 | 原理、增删查、key 与 key‑value 双版本实现、看懂 set/map 底层

原创 于 2026-08-06 17:53:52 发布 · 212 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
C++

当前文章被收录于：

C++
17 篇文章 2 人学习

C++ 学习专栏，涵盖基础语法、面向对象、STL 容器、高阶数据结构与底层原理，记录学习踩坑与实战源码，面向后端开发岗位学习。

订阅专栏 查看详情
高阶数据结构

当前文章被收录于：

高阶数据结构
1 篇文章 0 人学习

C++ 高阶数据结构专题，手撕 BST、AVL、红黑树、B + 树、跳表，剖析 STL 容器底层原理，夯实后端面试核心基础。

订阅专栏 查看详情
话题
#CodingPlan·八月创作之星博客挑战赛

目录

引言：

1.二叉搜索树的概念

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

3.二叉搜索树的插入原理

4.二叉搜索树的查找原理

5.二叉搜索树的删除原理

6.二叉搜索树的实现

6.1.构建初架构

拓展：using关键字

6.2.插入实现（Insert）

6.3.析构实现

6.4.Print实现（测试）

6.5.查找实现（find）

6.6.删除实现（erase）

6.7.拷贝构造，赋值实现

6.8.源码

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

7.1.key搜索场景（对应set容器）

7.2.key/value搜索场景（对应map容器）

7.3.key/value二叉搜索树代码实现

结语：

引言：

从本篇开始，我们正式进入高阶数据结构的学习阶段。 标准进阶学习路线推荐：普通二叉搜索树 → 平衡二叉搜索树 → AVL 树 → 红黑树 → B 树 / B + 树系列。

二叉搜索树是所有后续平衡树的基石，也是 C++ set/map的底层原型，非常重要。

那么话不多说，直接进入正文————>

                           

1.二叉搜索树的概念

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

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

这种就是二叉搜索树

特别注意：二叉搜索树中序遍历得到升序序列。

二叉树左子树中所有节点一定不大于根节点，右子树中所有节点一定不小于根节点 ，中序遍历的访问顺序是左中右，所以以中序遍历得到的序列就是升序序列

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

最优情况下，二叉搜索树为完全二叉树 (或者接近完全二叉树)，其高度为：log N

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

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

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

另外需要说明的是，二分查找也可以实现O(log N)级别的查找效率，但是二分查找有两大缺陷：

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

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

3.二叉搜索树的插入原理

我这里先讲理论，后实现

插入的具体过程如下：

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

就比如，一个二叉搜索树已经构建成了这样

我想插入16就走这条红线路

我想插入3就走这条红线路（这里相同情况下是往右走，往左走当然也可以，只要逻辑一致就可以）

4.二叉搜索树的查找原理

  • 从根开始比较，查找 x，x 比根的值大则往右边走查找，x 比根值小则往左边走查找。
  • 最多查找高度次，走到到空，还没找到，这个值不存在。
  • 如果不支持插入相等的值，找到 x 即可返回
  • 如果支持插入相等的值，意味着有多个 x 存在，一般要求查找中序的第一个 x。如下图，查找 3，要找到 1 的右孩子的那个 3 返回（因为是查找中序的第一个x，所以我们遇到找到x后要往左子树接着找）

5.二叉搜索树的删除原理

首先查找元素是否在二叉搜索树中，如果不存在，则返回 false。 如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为 N）

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

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

  1. 把 N 结点的父亲对应孩子指针指向空，直接删除 N 结点（情况 1 可以当成 2 或者 3 处理，效果是一样的）
  2. 把 N 结点的父亲对应孩子指针指向 N 的右孩子，直接删除 N 结点
  3. 把 N 结点的父亲对应孩子指针指向 N 的左孩子，直接删除 N 结点
  4. 无法直接删除 N 结点，因为 N 的两个孩子无处安放，只能用替换法删除。找 N 左子树的值最大结点 R (最右结点) 或者 N 右子树的值最小结点 R (最左结点) 替代 N，因为这两个结点中任意一个，放到 N 的位置，都满足二叉搜索树的规则。替代 N 的意思就是 N 和 R 的两个结点的值交换，转而变成删除 R 结点，R 结点符合情况 2 或情况 3，可以直接删除。

6.二叉搜索树的实现

        我们设计二叉搜索树的时候会有俩份版本，一份是支持冗余的（有重复数字），一份是不支持冗余的（没有重复数字），这其实就是set和map底层的区别，我们这里实现不支持冗余的版本

我们这里实现的二叉搜索树实现了增删查的功能，改不实现，因为普通的二叉搜索树是不允许修改的（因为如果改了，那树就可能不是二叉搜索树了，性质就被破坏了）

6.1.构建初架构

#pragma once
#include <iostream>
template<class K>
class BSTNode
{
public:
	BSTNode() = default;
	BSTNode(const K& _key)
		:_val(_key)
		, _left(nullptr)
		, _right(nullptr)
	{

	}

	K _val = 0;
	BSTNode<K>* _left = nullptr;
	BSTNode<K>* _right = nullptr;
};

template<class K>
class BSTree
{
	using Node = BSTNode<K>;
	//typedef BSTNode<K> Node;
public:

private:
	Node* _root = nullptr;
};

BSTNode就是代表节点，BSTree就是树

拓展：using关键字

        我们先前用重命名用的是typedef，也就是

	typedef BSTNode<K> Node;

        这里拓展一点，我们可以用using关键字来进行重命名，这效果是C++11后新增的东西，现在可以从typedef转到用using，因为using在普通场景下效果和typedef是一样的，但在有些场景挺有用，具体会在C++11部分具体讲using，这个用法也很简单，就是如下这样

	using Node = BSTNode<K>;

6.2.插入实现（Insert）

        这里实现的是无重复数据版本

template<class K>
bool BSTree<K>::insert(const K& key)
{
	if (_root == nullptr)
	{
		Node* node = new Node(key);
		_root = node;
		return true;
	}
	else
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_val > key)
				cur = cur->_left;
			else if (cur->_val < key)
				cur = cur->_right;
			else
				return false;
		}
		Node* node = new Node(key);
		if (parent->_val > key)
			parent->_left = node;
		else
			parent->_right = node;
		return true;
	}
}

6.3.析构实现

insert函数涉及了堆内存的开辟，那我们就实现一下析构

//类内
    //.....
	~BSTree()
	{
		Destroy(_root);
	}
	void Destroy(Node* root);
    //...

//类外
template<class K>
void BSTree<K>::Destroy(Node* root)
{
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

6.4.Print实现（测试）

        这里实现Print函数是为了测试实现的二叉搜索树有没有问题，为了不让外部直接调用带参的Print，我们可以封装一层,然后把带参的Print设为私有

template<class K>
void BSTree<K>::Print()
{
	Print(_root);
}

template<class K>
void BSTree<K>::Print(Node* root)
{
	if (root == nullptr)
		return;
	Print(root->_left);
	std::cout << root->_val << " ";
	Print(root->_right);
}

接下来，我们测试一下insert有没有问题

#define _CRT_SECURE_NO_WARNINGS
#include "Binary Search Tree.h"
#include <string>
using namespace std;
int main()
{
	BSTree<int> bsti;
	bsti.insert(1);
	bsti.insert(3);
	bsti.insert(2);
	bsti.insert(4);
	bsti.insert(4);
	bsti.Print();
	
	cout << endl;

	BSTree<string> bsts;
	bsts.insert("ababab");
	bsts.insert("baabab");
	bsts.insert("aabbab");
	bsts.insert("bbabab");
	bsts.insert("bbabab");
	bsts.Print();

	return 0;
}

对于内置类型和自定义类型都是没问题的

6.5.查找实现（find）

template<class K>
bool BSTree<K>::find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_val > key)
			cur = cur->_left;
		else if (cur->_val < key)
			cur = cur->_right;
		else
			return true;
	}
	return false;
}

测试一下

6.6.删除实现（erase）

template<class K>
bool BSTree<K>::erase(const K& key)
{
	if (_root == nullptr)
		return false;
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_val > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_val < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_right == cur)
						parent->_right = cur->_right;
					else
						parent->_left = cur->_right;
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_right == cur)
						parent->_right = cur->_left;
					else
						parent->_left = cur->_left;
				}
				delete cur;
			}
			else
			{
				Node* sparent = cur;
				Node* scur = cur->_right;
				while (scur->_left)
				{
					sparent = scur;
					scur = scur->_left;
				}
				cur->_val = scur->_val;
				if (sparent == cur)
					sparent->_right = scur->_right;
				else
					sparent->_left = scur->_right;
				delete scur;
				break;
			}
			return true;
		}
	}
	return false;
}

我用这份测试代码测试一下

#define _CRT_SECURE_NO_WARNINGS
#include "Binary Search Tree.h"
#include <string>
using namespace std;
int main()
{
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	BSTree<int> bsti;
	for (auto x : a)
		bsti.insert(x);
	bsti.Print();
	cout << endl;
	
	bsti.erase(3);
	bsti.Print();
	cout << endl;
	
	bsti.erase(14);
	bsti.Print();
	cout << endl;
	
	bsti.erase(8);
	bsti.Print();
	cout << endl;

	//BSTree<string> bsts;
	//bsts.insert("ababab");
	//bsts.insert("baabab");
	//bsts.insert("aabbab");
	//bsts.insert("bbabab");
	//bsts.insert("bbabab");
	//bsts.Print();
	//cout << bsts.find("aabbab") << " " << bsts.find("aabbbb");

	return 0;
}

没有问题 

6.7.拷贝构造，赋值实现

        为了预防浅拷贝，最后把拷贝构造和赋值实现一下就OK了

//类内
	BSTree<K>& operator=(BSTree<K> bst);

	BSTree() = default;

	BSTree(const BSTree& bst)
	{
		_root = Creat(bst._root);
	}
	Node* Creat(Node* root);



//类外
template<class K>
typename BSTree<K>::Node* BSTree<K>::Creat(Node* root)
{
	if (root == nullptr)
		return nullptr;
	Node* cur = new Node(root->_val);
	cur->_left = Creat(root->_left);
	cur->_right = Creat(root->_right);
	return cur;
}


template<class K>
BSTree<K>& BSTree<K>::operator=(BSTree<K> bst)
{
	std::swap(_root, bst._root);
	return *this;
}

6.8.源码

#pragma once
#include <iostream>
template<class K>
class BSTNode
{
public:
	BSTNode() = default;
	BSTNode(const K& _key)
		:_val(_key)
		, _left(nullptr)
		, _right(nullptr)
	{

	}

	K _val = 0;
	BSTNode<K>* _left = nullptr;
	BSTNode<K>* _right = nullptr;
};
//

template<class K>
class BSTree
{
	using Node = BSTNode<K>;

	//typedef BSTNode<K> Node;
public:
	bool insert(const K& key);
	bool find(const K& key);
	bool erase(const K& key);
	void Print();
	BSTree<K>& operator=(BSTree<K> bst);

	BSTree() = default;

	BSTree(const BSTree& bst)
	{
		_root = Creat(bst._root);
	}

	~BSTree()
	{
		Destroy(_root);
	}

private:
	Node* Creat(Node* root);
	void Print(Node* root);
	void Destroy(Node* root);
	Node* _root = nullptr;
};

template<class K>
bool BSTree<K>::insert(const K& key)
{
	if (_root == nullptr)
	{
		Node* node = new Node(key);
		_root = node;
		return true;
	}
	else
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_val > key)
				cur = cur->_left;
			else if (cur->_val < key)
				cur = cur->_right;
			else
				return false;
		}
		Node* node = new Node(key);
		if (parent->_val > key)
			parent->_left = node;
		else
			parent->_right = node;
		return true;
	}
}

template<class K>
void BSTree<K>::Destroy(Node* root)
{
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}


template<class K>
void BSTree<K>::Print()
{
	Print(_root);
}

template<class K>
void BSTree<K>::Print(Node* root)
{
	if (root == nullptr)
		return;
	Print(root->_left);
	std::cout << root->_val << " ";
	Print(root->_right);
}

template<class K>
bool BSTree<K>::find(const K& key)
{
	if (_root == nullptr)
		return false;
	Node* cur = _root;
	while (cur)
	{
		if (cur->_val > key)
			cur = cur->_left;
		else if (cur->_val < key)
			cur = cur->_right;
		else
			return true;
	}
	return false;
}

template<class K>
bool BSTree<K>::erase(const K& key)
{
	if (_root == nullptr)
		return false;
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_val > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_val < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_right == cur)
						parent->_right = cur->_right;
					else
						parent->_left = cur->_right;
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_right == cur)
						parent->_right = cur->_left;
					else
						parent->_left = cur->_left;
				}
				delete cur;
			}
			else
			{
				Node* sparent = cur;
				Node* scur = cur->_right;
				while (scur->_left)
				{
					sparent = scur;
					scur = scur->_left;
				}
				cur->_val = scur->_val;
				if (sparent == cur)
					sparent->_right = scur->_right;
				else
					sparent->_left = scur->_right;
				delete scur;
				break;
			}
			return true;
		}
	}
	return false;
}


template<class K>
typename BSTree<K>::Node* BSTree<K>::Creat(Node* root)
{
	if (root == nullptr)
		return nullptr;
	Node* cur = new Node(root->_val);
	cur->_left = Creat(root->_left);
	cur->_right = Creat(root->_right);
	return cur;
}


template<class K>
BSTree<K>& BSTree<K>::operator=(BSTree<K> bst)
{
	std::swap(_root, bst._root);
	return *this;
}

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

二叉搜索树使用主要是俩个场景，key搜索场景和key/value搜索场景

7.1.key搜索场景（对应set容器）

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

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

场景 2：检查一篇英文文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在二叉搜索树中，不在则波浪线标红提示。（可以把VS我们输错关键词爆红理解成这样）

key搜索场景简单说就是在不在（也就是对应我们之后的set容器）

7.2.key/value搜索场景（对应map容器）

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

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

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

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

7.3.key/value二叉搜索树代码实现

        这个实现其实就是在原先的key搜索场景的基础上改改就行了，这里我就直接放代码了

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

		}

		K _key;
		V _value;
		BSTNode<K, V>* _left = nullptr;
		BSTNode<K, V>* _right = nullptr;
	};
	//

	template<class K, class V>
	class BSTree
	{
		using Node = BSTNode<K, V>;

		//typedef BSTNode<K> Node;
	public:
		bool insert(const K& key, const V& value);
		Node* find(const K& key);
		bool erase(const K& key);
		void Print();
		BSTree<K,V>& operator=(BSTree<K,V> bst);

		BSTree() = default;

		BSTree(const BSTree& bst)
		{
			_root = Creat(bst._root);
		}

		~BSTree()
		{
			Destroy(_root);
		}

	private:
		Node* Creat(Node* root);
		void Print(Node* root);
		void Destroy(Node* root);
		Node* _root = nullptr;
	};

	template<class K, class V>
	bool BSTree<K,V>::insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			Node* node = new Node(key, value);
			_root = node;
			return true;
		}
		else
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				parent = cur;
				if (cur->_key > key)
					cur = cur->_left;
				else if (cur->_key < key)
					cur = cur->_right;
				else
					return false;
			}
			Node* node = new Node(key, value);
			if (parent->_key > key)
				parent->_left = node;
			else
				parent->_right = node;
			return true;
		}
	}

	template<class K, class V>
	void BSTree<K, V>::Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}


	template<class K, class V>
	void BSTree<K, V>::Print()
	{
		Print(_root);
	}

	template<class K, class V>
	void BSTree<K, V>::Print(Node* root)
	{
		if (root == nullptr)
			return;
		Print(root->_left);
		std::cout << root->_key << "->" << root->_value << " ";
		Print(root->_right);
	}

	template<class K, class V>
	typename BSTree<K, V>::Node* BSTree<K, V>::find(const K& key)
	{
		if (_root == nullptr)
			return nullptr;
		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;
	}

	template<class K, class V>
	bool BSTree<K, V>::erase(const K& key)
	{
		if (_root == nullptr)
			return false;
		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->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_right;
						else
							parent->_left = cur->_right;
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right == cur)
							parent->_right = cur->_left;
						else
							parent->_left = cur->_left;
					}
					delete cur;
				}
				else
				{
					Node* sparent = cur;
					Node* scur = cur->_right;
					while (scur->_left)
					{
						sparent = scur;
						scur = scur->_left;
					}
					cur->_key = scur->_key;
					cur->_value = scur->_value;
					if (sparent == cur)
						sparent->_right = scur->_right;
					else
						sparent->_left = scur->_right;
					delete scur;
					break;
				}
				return true;
			}
		}
		return false;
	}


	template<class K, class V>
	typename BSTree<K, V>::Node* BSTree<K, V>::Creat(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* cur = new Node(root->_key, root->_value);
		cur->_left = Creat(root->_left);
		cur->_right = Creat(root->_right);
		return cur;
	}


	template<class K, class V>
	BSTree<K, V>& BSTree<K, V>::operator=(BSTree<K, V> bst)
	{
		std::swap(_root, bst._root);
		return *this;
	}
}

实现完了后可以用下面俩份测试代码测试一下 

#define _CRT_SECURE_NO_WARNINGS
#include "Binary Search Tree.h"
#include <string>
using namespace std;
int main()
{
	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;
}
#define _CRT_SECURE_NO_WARNINGS
#include "Binary Search Tree.h"
#include <string>
using namespace std;


int main()
{
	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.Print();
	return 0;
}

结语：

        那么，用C++实现的高阶数据结构的二叉搜索树部分的内容就全部讲解完毕啦，希望以上内容对你有所帮助，感谢观看，若觉得写的还可以，可以分享给朋友一起来看哦，毕竟一起进步更有动力嘛，当然能关注一下就更好啦。

标签
#c++ #数据结构 #开发语言 #二叉搜索树树（BST） #高阶数据结构
C++：splog
becky_lyl的博客
08-03 43
.
nlohmann/json 深度解析：让 C++ 解析 JSON 像喝水一样简单
最新发布
ITOfDragon的博客
08-05 257
nlohmann/json 之所以成为 C++ 社区最受欢迎的 JSON 库，不是因为它最快，而是因为它把 C++ 处理 JSON 的痛苦降到了最低：单头文件零配置、STL 容器无缝互转、异常处理友好、代码像 Python 一样好读。它适合 90% 的日常场景——配置文件、网络报文、对象持久化、测试数据构造，几乎无处不在。最后送你三句口诀：读：json::parse 读进来，at() 安全取；写：初始化列表构建，dump() 序列化出去；避坑。
C++：6.编译加载过程的进一步说明
zjun1001的博客
08-01 263
文章摘要： 程序编译过程分为预处理、编译、汇编和链接四个阶段。预处理进行文本替换和宏展开；编译检查语法并生成汇编代码；汇编将代码转为机器指令，生成包含段信息和符号表的目标文件；链接合并目标文件，完成地址重定位和动态库加载。主要报错发生在编译（语法错误）和链接阶段（符号冲突或缺失）。通过readelf、nm、patchelf等工具可查看目标文件结构、符号表和动态库信息。动态库通过soname标识实现版本兼容，运行时由ld-linux动态链接器加载依赖库并完成地址重定位。
c++二级指针
爱CV
08-03 315
维度一维大块内存 (float*)二级指针数组 (float**)内存分配/释放一次分配，极快，防泄漏循环分配/释放，极慢，极易泄漏CPU 缓存命中率最优 (接近 100%)极差 (频繁 Cache Miss)硬件预取器状态完美激活，满速流水线失效，产生流水线气泡SIMD (AVX) 支持完美兼容，易于对齐难以跨行操作，边界处理复杂多线程 (OpenMP) 友好度完美，可以简单切分连续地址段存在伪共享风险，跨核同步成本高。
C++课后习题训练记录Day175
zmzb0103的博客
08-01 222
注意每段代码末尾的分号是否存在 ，如不存在则需即使补充；输入法是否切换为英语模式；给定一个字符串 S ，请找出 S 的一个前缀和后缀，使得它们拼接后是一个回文串。对此代码进行检验，检验后无报错，提交此代码，判题结果为正确100分。在蓝桥云课中选择题库，选择题号17148并开始练习。输入一行包含一个字符串 S ，由小写英文字母组成。输出一行包含一个整数表示答案。请输出这个串的最长长度。
C++ 视图类型底层实现深度解析：std::span 与 std::string_view 的零拷贝设计哲学
ITOfDragon的博客
08-04 335
SSO（Small String Optimization，小字符串优化）：std::string 对短字符串（通常 ≤ 15 或 ≤ 22 字符，取决于实现）不分配堆内存，而是把字符直接塞进对象内部的固定缓冲区。SBO（Small Buffer Optimization，小缓冲区优化）：同类思想在 std::function、std::any 等类型中的泛化名称。// 短：放进对象内部缓冲区，不分配堆// libstdc++ 上通常是 32：短字符串用其中 16 字节存字符，其余存指针等。
C++ 类和对象详解(4)初始化列表，static成员，友元，内部类，匿名对象
日拱一卒,功不唐捐
08-03 249
本文系统介绍了C++类和对象的核心概念，主要内容包括：1）初始化列表的语法规则与使用场景，强调const成员、引用成员等必须使用初始化列表；2）静态成员特性，说明其存储位置和访问规则；3）友元机制，分析友元函数和友元类的作用及设计考量；4）内部类的定义与封装特性；5）匿名对象的生命周期特点。文章通过对比不同初始化方式、成员访问规则等，帮助读者深入理解C++面向对象编程的关键技术要点。
C++ 反向迭代器万字详解 | 新旧双版本实现、迭代器萃取、STL源码剖析
lingran__的博客
08-01 330
本文详细讲解了C++反向迭代器的实现原理。通过分析SGI-STL3.0源码，介绍了三种反向迭代器类模板的设计思路：适配器模式利用正向迭代器实现反向功能，避免了重复开发。重点对比了老版本（多模板参数）和新版本（单模板参数+迭代器萃取）的实现方式，并给出了具体代码示例。最后通过vector容器的反向迭代器实现演示了实际应用，验证了方案的可行性。文章为理解STL反向迭代器设计提供了清晰的思路和实用的实现方法。
【C++】022、深拷贝&浅拷贝
Tim_10的博客
08-03 208
移动是把源对象的指针直接置空（nullptr），并把指针值偷给目标对象，移动后的源对象处于有效但未指定的状态，他的析构函数不会再释放资源。如果一个类需要自定义析构函数释放资源，那么一定需要自定义拷贝构造函数和拷贝赋值运算符，以及C11后的移动构造和移动赋值。浅拷贝：仅仅逐字节复制对象本身的内存布局，两个对象中的指针成员指向同一块动态内存。反之，如果不需要析构函数，就不要自定义拷贝操作，直接让编译器生成默认的浅拷贝。C++中的移动语义既不是深拷贝，也不是浅拷贝，只是一种资源窃取。深拷贝会复制一份数据（昂贵）
【C语言】01-从零开始：编译运行与第一个程序
福州最帅男模的博客
08-04 214
编译运行与第一个程序
C语言标准演化史：从K&R到GNU，谁才是正统？
stevenseahang的博客
08-04 248
你知道吗？如今最流行的C语言编译器，其实并不完全遵守C语言标准。换句话说，你写的代码，可能根本就不是“标准C”。这听起来有点反常识，但真相是，C语言从诞生那天起
C++ STL 容器详解 —— vector 动态数组容器全面学习笔记
m0_74978334的博客
08-04 346
Student s1;s1.age=18;vector可以存：intdoublestring类对象结构体vector 是 C++ STL 中最重要的容器之一。知识点重点底层结构动态数组内存特点连续空间三个指针size有效元素数量capacity申请空间大小扩容重新申请空间并拷贝访问随机访问O(1)尾插平均O(1)中间插入O(n)迭代器可能失效优势访问快缺点扩容和移动成本。
【C++ 容器】vector
EnHengNa的博客
07-31 327
C++11 核心升级：列表初始化、移动语义、emplace原地构造、范围 for、优先使用push_back，范围 for，reserve预分配最佳实践：尾插尾删、提前分配内存、避免中间操作、注意迭代器失效vector 适用场景：需要随机访问、元素个数变化、尾部频繁增删。
嵌入式 软件C 语言八股文复习笔记６——常见笔面试题型与综合实战
m0_62302696的博客
08-03 219
本文详细介绍了嵌入式C语言开发的六大核心技能模块，涵盖面试常见考点和实际应用场景。主要内容包括：手写经典C库函数（如memcpy、memmove）的关键实现要点与评价标准；C语言陷阱语法题和未定义行为的典型示例解析；链表操作与状态机在嵌入式系统中的三种实现方式；环形缓冲区的无锁设计与注意事项；结合硬件场景的代码改错技巧与寄存器操作规范；以及简单任务调度器和命令解析器的设计方法。文章通过大量代码示例和问题分析，帮助读者掌握嵌入式开发中的核心编程能力和面试应对技巧，特别强调了对健壮性、效率、硬件特性等关键问题的
现代C++随谈：未检查的指针与泛型编程的边界
charlie114514191的博客
07-31 390
本文探讨了现代C++中指针安全性和泛型编程的边界问题。作者首先指出未检查指针的安全隐患，强调应尽快将裸指针包装进类型安全的容器。接着通过number_of模板类展示如何利用CTAD简化类型安全数值的书写，仅37行代码就解决了数值隐式转换问题。文章重点讨论了std::sort的传统问题——当传入不满足要求的迭代器时，编译器报错信息难以理解，指出这反映了泛型编程长期缺乏类型约束检查的缺陷。最后提到C++20引入的concepts终于解决了这一问题，使泛型编程能够明确表达对参数的要求，让错误信息更直观。全文通过具
【C语言】02-变量、数据类型与存储
福州最帅男模的博客
08-04 356
变量、数据类型与存储
C语言——深度理解指针（5）
Chen_LSN的博客
08-04 733
本文介绍了回调函数的概念及qsort函数的使用方法。回调函数是通过函数指针间接调用的函数，其特点是由外部条件触发而非直接调用。文章通过加法运算示例展示了回调函数的实现原理。 qsort是C标准库中的快速排序函数，可对各种数据类型进行排序。文章详细讲解了qsort的参数和使用方法，并提供了多个示例： 整型数组排序 字符数组排序 字符串数组排序 浮点数数组排序 结构体数组排序（按年龄和姓名） 最后补充了结构体成员访问操作符(.和->)的使用区别，帮助理解结构体指针访问成员的方式。全文通过代码示例详细演示了各种数
C++(黑马)01-基础
2401_82749999的博客
08-04 218
所谓数组，就是一个集合，里面存放了相同类型的数据元素**特点1：**数组中的每个数据元素都是相同的数据类型**特点2：**数组是由连续的内存位置组成的数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};数据类型 数组名[ ] = { 值1，值2 ...};示例//定义方式1//数据类型 数组名[元素个数];//利用下标赋值//利用下标输出//第二种定义方式//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};
[AI][C++26] SIMD 编程模型思考
mlidongfeng的博客
08-03 296
SIMD 处理固定为 128B, 与 GPU的warp 处理长度对齐simd-tile：以 128B 字节为长度的向量单位。整块（full tile）：一整块 128B 的有效载荷，走无谓词快速路径。尾块（tail / epilogue）：少于 128B 的剩余元素，单独作 epilogue 处理（mask/narrow/scalar）。
2025 年 3 月青少年软编等考 C 语言四级真题解析
学习过程的记录与分享。
07-31 155
T1. 两枚硬币：给定n个硬币和价格m，寻找两枚硬币使其面值之和等于m。解法包括枚举法（时间复杂度O(m)）和双指针法（时间复杂度O(n)），后者更高效。 T2. 完美数列：给定数列和参数p，寻找满足最大值≤最小值×p的最长子序列。通过排序和尺取法（滑动窗口）在O(n log n)时间内高效求解。 T3. 多样解码：计算数字串解码为大写字母的不同方式数目，使用动态规划计数，状态转移考虑单字符和双字符解码情况，初始条件为f₀=f₁=1，最终结果对1e9+7取模。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值