【C++】19：二叉搜索数

最新推荐文章于 2025-12-17 23:40:21 发布
原创 最新推荐文章于 2025-12-17 23:40:21 发布 · 632 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #数据结构 #算法

目录

一、二叉搜索树的概念

二、二叉搜索树的性能分析

三、二叉搜索树的插入

四、二叉搜索树的中序遍历

五、二叉搜索树的查找

六、二叉搜索树的删除

七、二叉搜索树的实现代码

7.1 BinarySearchTree.h

7.2 test.cpp

八、二叉搜索树key和key/value的使用场景

8.1 key搜索场景

8.2 key/value搜索场景

九、key/value二叉搜索树实现代码

9.1 BinarySearchTree.h

9.2 test.cpp

一、二叉搜索树的概念

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

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

二、二叉搜索树的性能分析

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

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

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

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

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

  1. 需要存储在支持下标随机访问的结构中，并且有序。

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

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

三、二叉搜索树的插入

插入的具体过程如下：

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

插入16：

插入3：

bool insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return bool;
	}

	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
	{
		parent->_right = newnode;
	}
	return true;
}

四、二叉搜索树的中序遍历

二叉树的中序遍历是先走左子树，再访问根，最后再访问右子树，但是在二叉搜索树中，左子树中的值是小于根节点的值，根节点的值小于右子树中的值，所以中序二叉搜索树的中序遍历就是一个递增的序列。

但是有一个问题，我们在中序遍历是需要传入根节点的指针的，但是根节点的指针式private，外面不能访问，那该怎么办呢？

虽然在类外面不可以访问根节点的指针，但是在类里面是可以访问根节点的指针的，于是我们可以给中序遍历套一个马甲，如下所示：

public:	
void InOrder()
	{
		_InOrder(_root);
	}
private:

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

五、二叉搜索树的查找

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

六、二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回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，可以直接删除。

bool Erase(const K& key)
{
	//删除这个节点需要先找到这个节点
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//找到了这个节点之后进行删除，分三种情况
			//删除
			//1:这个节点的左孩子为空
			//2:这个节点的右孩子为空
			//3:这个节点的左右孩子都不为空

			if (cur->_left == nullptr)   //1:这个节点的左孩子为空
			{
				if (cur == _root)  //当删除这个节点是根节点，且左孩子为空
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;

			}
			else if (cur->_right == nullptr)//2:这个节点的右孩子为空
			{
				if (cur == _root)  //当删除这个节点是根节点，且右孩子为空
				{
					_root = cur->_left;
				}
				else 
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;	
			}
			else//3:这个节点的左右孩子都不为空
			{
				//查找替代节点，找右子树的最左节点（也可以找左子树的最右节点）
				Node* replace = cur->_right;
				Node* replaceparent = cur;
				while (replace->_left)
				{
					replaceparent = replace;
					replace = replace->_left;
				}
				cur->_key = replace->_key;
				if (replaceparent->_left == replace)
				{
					replaceparent->_left = replace->_right;
				}
				else 
				{
					replaceparent->_right = replace->_right;
				}

				delete replace;
					
			}
			return true;
		}
	}

	return false;//走到这里表示二叉树里面没有这个节点删除失败

}

七、二叉搜索树的实现代码

7.1 BinarySearchTree.h

#pragma once
#include<iostream>
using namespace std;

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

	BSTNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};
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->_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
		{
			parent->_right = newnode;
		}
		return true;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	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* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//找到了这个节点之后进行删除，分三种情况
				//删除
				//1:这个节点的左孩子为空
				//2:这个节点的右孩子为空
				//3:这个节点的左右孩子都不为空

				if (cur->_left == nullptr)   //1:这个节点的左孩子为空
				{
					if (cur == _root)  //当删除这个节点是根节点，且左孩子为空
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;

				}
				else if (cur->_right == nullptr)//2:这个节点的右孩子为空
				{
					if (cur == _root)  //当删除这个节点是根节点，且右孩子为空
					{
						_root = cur->_left;
					}
					else 
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;	
				}
				else//3:这个节点的左右孩子都不为空
				{
					//查找替代节点，找右子树的最左节点（也可以找左子树的最右节点）
					Node* replace = cur->_right;
					Node* replaceparent = cur;
					while (replace->_left)
					{
						replaceparent = replace;
						replace = replace->_left;
					}
					cur->_key = replace->_key;
					if (replaceparent->_left == replace)
					{
						replaceparent->_left = replace->_right;
					}
					else 
					{
						replaceparent->_right = replace->_right;
					}

					delete replace;
						
				}
				return true;
			}
		}

		return false;//走到这里表示二叉树里面没有这个节点删除失败

	}
private:
	Node* _root = nullptr;

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

};

7.2 test.cpp

#include"BinarySearchTree.h"

int main()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> bs;
	for (auto ele : a)
	{
		bs.insert(ele);
	}
	bs.InOrder();
	///*bs.Erase(8);
	//bs.InOrder();*/*/
	for (auto ele : a)
	{
		bs.Erase(ele);
		bs.InOrder();
	}
	return 0;
}

八、二叉搜索树key和key/value的使用场景

8.1 key搜索场景

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

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

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

8.2 key/value搜索场景

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

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

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

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

九、key/value二叉搜索树实现代码

9.1 BinarySearchTree.h

#include<iostream>
using namespace std;
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->_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
			{
				parent->_right = newnode;
			}
			return true;
		}
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
		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* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//找到了这个节点之后进行删除，分三种情况
					//删除
					//1:这个节点的左孩子为空
					//2:这个节点的右孩子为空
					//3:这个节点的左右孩子都不为空

					if (cur->_left == nullptr)   //1:这个节点的左孩子为空
					{
						if (cur == _root)  //当删除这个节点是根节点，且左孩子为空
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;

					}
					else if (cur->_right == nullptr)//2:这个节点的右孩子为空
					{
						if (cur == _root)  //当删除这个节点是根节点，且右孩子为空
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else//3:这个节点的左右孩子都不为空
					{
						//查找替代节点，找右子树的最左节点（也可以找左子树的最右节点）
						Node* replace = cur->_right;
						Node* replaceparent = cur;
						while (replace->_left)
						{
							replaceparent = replace;
							replace = replace->_left;
						}
						cur->_key = replace->_key;
						if (replaceparent->_left == replace)
						{
							replaceparent->_left = replace->_right;
						}
						else
						{
							replaceparent->_right = replace->_right;
						}

						delete replace;

					}
					return true;
				}
			}

			return false;//走到这里表示二叉树里面没有这个节点删除失败

		}
	private:
		Node* _root = nullptr;

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

9.2 test.cpp

#include"BinarySearchTree.h"
int main()
{
	key_value::BSTree<string, string> dict;
	dict.insert("left", "左边");
	dict.insert("right", "右边");
	dict.insert("insert", "插入");
	dict.insert("string", "字符串");
	dict.InOrder();

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

小张000000
关注
华为OD 技术综合面，手撕代码真题整理（85）：二叉搜索树中的逆序对 | 最大子矩阵
梦想橡皮擦，专栏100例写作模式先行者，现象级专栏 《Python 爬虫 100 例》作者、《滚雪球学 Python 专栏》原创者
10-07 150
OD，全名 Outsourcing Dispacth，中文外包派遣。华为 19 年开始探索并实行新的研发“人力外包”模式，按正式员工标准进行招聘（话虽如此，实际要求没那么高），由业务部门负责培养和管理，解决更为核心的业务问题，对于绩效优秀且能力突出的人才提供转正式员工通道。人力外包签约方为德科/科锐国际，劳动合同期为 4 年，试用期 6 个月。员工关系、五险一金、考勤发薪由德科/科锐国际负责；定级定薪、员工培训、工作安排、绩效评比和晋升等由华为负责。
【C++】二叉搜索树
qq_62939852的博客
04-18 1932
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
19.树：二叉搜索树的实现
weixin_51437378的博客
09-12 327
退出：判断当前头节点。
c++：二叉搜索树的简析与详细实现（万字）
qq_62718027的博客
07-27 902
该树的任意一个子树都要满足左子树的值
剑指offer系列19：二叉搜索树与双向链表
weixin_30414635的博客
06-24 88
二叉搜索树的特点是根据中序遍历就是从小到大的顺序。所以要根据左->根->右的顺序进行递归。整体思路就是：按着中序遍历的顺序将树中的每一个结点与前一个结点连接起来。 递归的时候想一个问题，只要能把两个节点连起来，就能把所有的树的结点连起来。这个题还是很典型。 在表示尾结点的时候，我还在想这个使用一个指针不也可以吗，结果调试了发现不行。因位如果使用指针表示尾结点，则在递归的过程中不会更...
CC40.【C++ Cont】二叉搜索树和平衡二叉树
zhangcoder的博客 记录学习轨迹~
03-04 1474
二叉搜索树(Binary Search Tree,简称BST),又称二叉排序树若左子树非空,则左子树所有节点的值均小于根节点的值;若右子树非空,则右子树所有节点的值均大于根节点的值左右子树也是一棵二叉搜索树即左<根<右,因此中序遍历的结果是从小到大(图来自《程序是怎样跑起来的》第81页)从图中可以看出:第二层:从左到右:30<75;第三层:从左到右:17<41<63<84;中序遍历为:17-->30-->41-->50-->63-->75-->84。
C++---二叉搜索树
qq_47406941的博客
05-19 780
一、二叉搜索树的概念 二叉搜索树又称二叉排序树，它是一颗空树或者是具有以下性质的树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树的操作 1、查找 基本思路： 根节点为空，返回false 根节点不为空，比较根节点和要找的值是否相等，相等返回true。 根节点和要找的值不想等时，判断跟节点和要找的值的关系。 如果根节点小于要找到的值，则在右子树找 如果根节点大于要
[C++] 实现二叉搜索树
LeYOUNGER的博客
07-13 488
在学STL的关联容器的时候，遇到了一些树，这里把它实现一下
数据结构复习：二叉排序树的实现
rj2017211811的博客
07-29 429
二叉排序树
C++ 实现二叉搜索树
sushhsishdgsusk的博客
09-13 357
可以说，二叉搜索树在查找上面的进步是很大，他的平均查找速度为O(logN),最坏查找情况为O(N）。（N为树的高度）为什么呢，其实类似于二分查找，它每次在查找的时候都只会前往左右区间，也就是直接剔除一半的值，最后便得出平均查找速度。最坏查找是因为有特殊情况，（一般是有序）使二叉树退化成单子树，从而大幅降低了查找效率。
四、高级数据结构和算法：二叉搜索树（BST树）、平衡二叉树（AVL树）
小脑斧的博客
06-18 473
BST树和AVL树的基本操作
【C++】 二叉排序树BST(二叉搜索树)
2301_77649794的博客
04-22 1387
看似删除节点有4种情况，但实际上a和b和c可以合并，这样就只有2种情况了： a:待删除的结点无孩子/只有一个孩子：删除结点并使父亲结点指向被删除结点的孩子结点（无孩子视为孩子是空结点，任意指向一个即可） b:待删除的结点有左右孩子：采用替换法，寻找删除结点右子树的最小结点（右子树最左结点），将最小结点的值和删除结点的值替换，然后删除最小结点（此时最小结点，要么没有孩子，要么只有一个孩子，符合a情况可以直接删除）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。，走到空，还没找到，则这个值不存在。
深入理解 C++ 中的二叉搜索树（BST）：实现与操作
weixin_74431979的博客
03-26 1556
二叉搜索树是一种层次化的数据结构，由节点组成，每个节点最多有两个孩子，分别称为左孩子和右孩子。BST 属性确保对于每个节点，左子树中的所有元素都小于节点的值，右子树中的所有元素都大于节点的值。
二叉搜索（排序）树的算法实现（C++描述）
陈子青的博客
07-23 600
目录 定义 数据结构 二叉搜索树插入节点 二叉搜索树删除节点 二叉搜索树搜索 二叉树的遍历 程序清单 定义 二叉搜索树又称二叉查找树、二叉排序树（Binary Sort Tree）。它是一颗空树或是满足下列性质的二叉树： 1）若左子树不空，则左子树上所有节点的值均小于或等于它的根节点的值； 2）若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值； 3）左、右子树也分别为二叉排序树。 数据结构 二叉树一般采用链式存储方式：每个结点包含两个指针域，指...
C++ -- 哈希表
2301_80059080的博客
12-12 1429
本文系统介绍了哈希表的核心概念与实现方法。首先阐述了哈希的基本思想：通过哈希函数建立键值与存储位置的映射关系，实现O(1)时间复杂度的操作。然后详细讲解了哈希函数设计（包括除法散列法、乘法散列法等）和冲突处理策略，重点分析了开放定址法（线性探测、二次探测、双重散列）和链地址法两种主要冲突解决方案。文章还提供了完整的C++实现代码，包括哈希表结构设计、扩容机制、插入/查找/删除操作等关键算法，并通过示例演示了哈希表的工作过程。最后比较了不同方法的优缺点，指出链地址法在实践中的优势。
C++核心特性精讲：从C语言痛点出发，掌握现代C++编程精髓（超详细）
weixin_71604156的博客
12-15 697
本文深入探讨了从C语言转向C++的必要性，重点分析了C语言在大型项目管理中的核心痛点，并展示了C++如何通过命名空间(namespace)机制优雅解决这些问题。文章首先指出C语言在命名冲突、指针管理、函数设计等方面的不足，然后详细讲解了C++命名空间的多种应用方式，包括基本命名空间、嵌套命名空间、匿名命名空间和命名空间别名，并通过丰富的代码示例演示了它们在工程实践中的应用。命名空间为C++提供了模块化组织能力，有效解决了标识符冲突问题，是构建大型软件系统的重要基础特性。
如何快速在 VS2026 上使用 C++ 模块 — 完整上手指南
charlie114514191的博客
12-15 805
本文介绍了在VS2026中使用C++20模块特性的完整指南。文章首先阐述了模块的优势，如增量编译和更健壮的导出机制。接着提供了使用前提条件，包括VS2026的安装和C++标准设置。通过一个包含模块接口单元(math.ixx)和主程序(main.cpp)的最小示例，详细说明了模块的创建和使用方法。最后，文章指导读者在VS2026 IDE中配置项目、添加模块文件并设置语言标准，以顺利构建运行模块化程序。文末还提供了微软官方的相关参考资料。
【实战】C/C++ 实现 PC 热点（手动开启）+ 手机 UDP 自动发现 + TCP 通信全流程（超详细）
最新发布
weixin_71604156的博客
12-17 659
本文提出了一种PC与手机本地无线通信的完整解决方案。通过手动开启PC热点、UDP广播自动发现和TCP可靠通信的技术组合，实现了设备间免配置的稳定连接。方案包含详细的技术原理分析、跨平台实现代码（C/C++和Android/Kotlin）以及实际部署指南，解决了传统方案中IP配置复杂、网络依赖强等问题。核心创新点在于解耦热点创建与通信逻辑，采用UDP发现+TCP通信+心跳保活的三重机制，在保证通信可靠性的同时降低了权限要求和实现复杂度。
【C++】--AVL树的认识和实现
2302_81083101的博客
12-14 864
前面我们学习了二叉搜索树，其在一般情况下，对数据的查找的效率为O(logN)，但是在极端的情况下，其时间复杂度会达到O(n)。如下：右边的单支或者接近单支的情况就会导致查找的效率变得很低。所以后来又发明了AVL树，AVL树是两个前苏联科学家在1962年发表的。其概念如下：AVL树最先发明自平衡二叉查找树，其是一棵空树，或者具有以下性质的二叉树，它的左右子树也都是AVL树，然后左右子树的高度差不能超过1。AVL树是一棵高度平衡二叉树，其通过控制高度差去控制平衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值