【红黑树】

已于 2024-08-13 09:24:12 修改
阅读量850 收藏 27
点赞数 17
分类专栏： C++ 文章标签： c++
于 2024-08-11 11:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79013877/article/details/141101575
版权

红黑树

小杨

红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
在这里插入图片描述

红黑树的性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 。----->每条路径黑色节点数量相等。
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

实际的红黑树，最长和最短并不一定存在。红黑树最短路径:h(全黑),最长路径:2*h(一黑一红).

最短路径*2>=最长路径
就查找而言，最短路径:logN,最长路径:2*logN.

红黑树节点定义

//枚举定义结点的颜色
enum Colour
{
	RED,
	BLACK
};

//红黑树结点的定义
template<class K, class V>
struct RBTreeNode
{
	//三叉链
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	//存储的键值对
	pair<K, V> _kv;

	//结点的颜色
	int _col; //红/黑

	//构造函数
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

红黑树结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：
在这里插入图片描述

红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

  1. 按照二叉搜索的树规则插入新节点
  2. 检测新节点插入后，红黑树的性质是否造到破坏

我们默认新节点默认颜色为红色(主动破坏红黑树的性质3),如果新节点默认是黑色(那就相当于破换了性质4),破坏性质3比较好控制一点.

分析种数情况:以下图这棵抽象树为例子:
注意:我们看到的树，可能是一棵完整的树，也可能是一棵子树。

红黑树其实就是先尽量调整颜色，实在不行的话就进行旋转。但是调整颜色的话主要看的是u，而根据u可以分成两种情况。1.u存在且为红；2.u不存在或者u存在且为黑。
在这里插入图片描述

情况一:cur为红，p为红，g为黑，u存在且为红

如果g是根节点，调整完成后，需要将g改成黑色。
如果g是子树，g一定有双亲，且g的双亲如果是红色，需要继续向上调整。

在具体分析之前，对为什么要继续进行向上调整的解释:
在这里插入图片描述

一、abcde都是空，cur是新增

解决方式：将p，u改为黑，g改为红，然后把g当成cur，继续向上调整。
在这里插入图片描述

二、如果cur不是新增节点，cur本来是黑(经调整后再变红)：
1. cde每条路径都只有一个黑色节点

若cde具有每条路径都只有一个黑色节点，那就是有3种情况.，此时a和b只能是是红色节点，否则，每条路径的黑色节点就不平衡了。
在这里插入图片描述
因此cde的组合情况有333=27种。
此时新增的红色节点有4种插入情况(新增节点一定是在a、b的下面)。样例为下图:
在这里插入图片描述

在这里插入图片描述

2.cde每条路径都只有二个黑色节点

如果cde具有2个黑色节点?
两个红色节点的红黑树的节点最多的那一种情况：
在这里插入图片描述
当然，对于上图最后一层节点是可有可无的，因为去掉了，也会是两个黑色节点。
也就是上图最后一层可能的情况:
在这里插入图片描述
这还没有结束，cde可能得情况还有:
在这里插入图片描述
还有一点是，cde可能是上述所有情况中分别不同的一种。
这时，a和b是每条路径有一个黑色节点的红黑树。
因此，此时情况是非常多的。

总结:cde分析的如果是含有n个黑色节点，那么a，b的就是含有n-1个黑色节点。
当然，上述的分析不管总数如何如何多，其实就是主要看变色即可。

情况二、u不存在或者u存在且为黑。

同理，这里的cur可能是新增(本来就是红的)；或者是cur本来是黑色但是经过调整之后才变成红色的。

此时p一定是红的，因为如果p是黑色的，那么他就一定不会进行选择。g一定是黑色的，因为p是红的，如果g为红的，那不就意味着之前就有连续的红节点了，就破坏规则了，就出问题了。
这里跟情况一不同的就是u的问题。

一、单旋情况

在这里插入图片描述
说明:u的情况有两种

  1. 如果u节点不存在，abcde都是空，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足红黑树性质4:每条路径黑色节点个数相同。
    在这里插入图片描述

  2. 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到上图左其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色有黑色改成红色。
    在这里插入图片描述
    如果按照上图这种情况的话，d和e分别有两种选择情况(空或者一个红),c有三种情况，为含有一个黑色节点，新增的cur有4种插入情况(a、b的左或者右)。也就是48种。

在这里插入图片描述

p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
p为g的右孩子，cur为p的右孩子，则进行左单旋转
p、g变色–p变黑，g变红

二、双旋情况

在这里插入图片描述
p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，
p为g的右孩子，cur为p的左孩子，则针对p做右单旋转
则转换成了情况2

红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质
bool IsValidRBTree()
{
	PNode pRoot = GetRoot();
	// 空树也是红黑树
	if (nullptr == pRoot)
		return true;
	// 检测根节点是否满足情况
	if (BLACK != pRoot->_color)
	{
		cout << "违反红黑树性质二：根节点必须为黑色" << endl;
		return false;
	}
	// 获取任意一条路径中黑色节点的个数
	size_t blackCount = 0;
	PNode pCur = pRoot;
	while (pCur)
	{
		if (BLACK == pCur->_color)
			blackCount++;
		pCur = pCur->_pLeft;
	}
	// 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
	size_t k = 0;
	return _IsValidRBTree(pRoot, k, blackCount);
}
bool _IsValidRBTree(PNode pRoot, size_t k, const size_t blackCount)
{
	//走到null之后，判断k和black是否相等
	if (nullptr == pRoot)
	{
		if (k != blackCount)
		{
			cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
			return false;
		}
		return true;
	}
	// 统计黑色节点的个数
	if (BLACK == pRoot->_color)
		k++;
	// 检测当前节点与其双亲是否都为红色
	PNode pParent = pRoot->_pParent;
	if (pParent && RED == pParent->_color && RED == pRoot->_color)
	{
		cout << "违反性质三：没有连在一起的红色节点" << endl;
		return false;
	}
	return _IsValidRBTree(pRoot->_pLeft, k, blackCount) &&
		_IsValidRBTree(pRoot->_pRight, k, blackCount);
}

红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

红黑树的应用

  1. C++ STL库 – map/set、mutil_map/mutil_set
  2. Java 库
  3. linux内核
  4. 其他一些库

红黑树实现代码:

#pragma once
#include <iostream>
#include <assert.h>
#include <vector>

using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	Colour _col;

	RBTreeNode(const pair<K, V> kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;

public:
	RBTree() = default;

	RBTree(const RBTree<K, V>& t)
	{
		_root = Copy(t._root);
	}

	RBTree<K, V>& operator = (RBTree<K, V> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			//如果插入的值比当前值大，就继续向他的右节点走，继续比较。
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			//如果插入的值比当前值小，就继续向他的左节点走，继续比较。
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//拥有相同的值，返回false，插入失败
				return false;
			}
		}

		//到这里，cur为空，也就是要开新节点并插入了
		cur = new Node(kv);
		cur->_col = RED;
		//判断新节点在当前父节点的左还是右
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		//跟父亲节点链接一下
		cur->_parent = parent;

		//开始进行判断，如果插入节点的父亲是红色节点，就进入循环
		while (parent && parent->_col == RED)
		{
			//变量存父亲的父亲
			Node* grandfather = parent->_parent;
			//判断新插入节点的父亲是左是右
			if (parent == grandfather->_left)
			{
				//变量存u(伯父)
				Node* uncle = grandfather->_right;
				//分情况讨论
				//1.伯父存在且为红
				if (uncle && uncle->_col == RED)
				{
					//将父亲和伯父的颜色变黑,并将外祖父变红
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				//2.伯父不存在或者伯父存在且为黑
				else
				{
					//判断当前节点是其父亲的左还是右
					//如果都在同一边高，那么就进行单旋
					//如果不是同一边高，那么就进行双旋
				   //单旋
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//双旋
					else
					{
						//左旋
						RotateL(parent);
						//右旋
						RotateR(grandfather);

						//变色(因为左旋的关系,cur代替了刚才parent的位置)
						cur->_col = BLACK;
						grandfather->_col = RED;
					}


					//旋转+变色 完了之后，就可以进行break了。 
					break;
				}
			}
			//parent在右
			else if (parent == grandfather->_right)
			{
				//用变量存储uncle
				Node* uncle = grandfather->_left;

				//分情况
				//uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					//将该节点的父亲和伯父全部变黑,并将祖父变红
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				//uncle不存在或者uncle存在且为黑
				else
				{
					//分情况
					//如果该节点为父亲的右就进行单旋

					if (cur == parent->_right)
					{
						RotateL(grandfather);

						//旋转后，将父亲的颜色变黑，将祖父的节点变红
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//如果该节点为父亲的左就进行双旋(右旋+左旋)
					{
						//右旋
						RotateR(parent);
						//左旋
						RotateL(grandfather);

						//将cur变黑，将祖父变红
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					//旋转完之后，就跳出循环即可
					break;
				}
			}
		}

		_root->_col = BLACK;//将根节点的颜色设为黑色(不惧怕任何情况)  
		return true;//插入成功返回true
	}


	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}


	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	int Size()
	{
		return _Size(_root);
	}

	int Height()
	{
		return _Height(_root);
	}

	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
		{
			return false;
		}

		// 参考值
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}
private:


	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			if (refNum != blackNum)
			{
				cout << "存在黑色节点的数量不相等的路径，预期黑色节点数：" << refNum << "，实际黑色节点数：" << blackNum << endl;
				return false;
			}

			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return Check(root->_left, blackNum, refNum)
			&& Check(root->_right, blackNum, refNum);
	}


	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

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

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	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->_kv);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);

		return newRoot;
	}

	// 左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		//将subR的左子树给与parent的右
		parent->_right = subRL;
		//如果subrl为真，那么就更新其的父亲。
		if (subRL)
			subRL->_parent = parent;

		//记录最初父节点的父亲。
		Node* parentParent = parent->_parent;
		//subr的左为parent
		subR->_left = parent;
		//更新parent的父亲节点
		parent->_parent = subR;

		//如果之前父亲节点的父亲为空，那么subR就是新的根。
		if (parentParent == nullptr)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		//如果之前父亲节点的父亲不为空，看之前的父亲节点，是其父亲的左还是右。
		else {
			if (parent == parentParent->_left)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}

			subR->_parent = parentParent;
		}
	}
	//右旋转
	void  RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		Node* parentParent = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parentParent == nullptr)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (parent == parentParent->_left)
			{
				parentParent->_left = subL;

			}
			else
			{
				parentParent->_right = subL;
			}

			subL->_parent = parentParent;
		}

	}
	//左旋转

private:
	Node* _root = nullptr;
};

void TestRBTree()
{
	RBTree<int, int> t;
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };
	//int a[] = { 3,7,11,9,14,15,16,26,18 };
	for (auto e : a)
	{
		t.Insert({ e,e });

		//cout << e << "->" << t.IsBalanceTree() << endl;
	}

	t.InOrder();
	cout << t.IsBalance() << endl;;

}


void TestAVLTree2()
{
	const int N = 10000 ;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (size_t i = 0; i < N; ++i)
	{
		v.push_back(rand());
		//cout<<v.back()<<endl;
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}

	size_t end2 = clock();

	cout << "insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;
	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;

	size_t begin1 = clock();
	//确定在的值
	for (auto e : v)
	{
		t.Find(e);
	}

	//随机值
	for (size_t i = 0; i < N; ++i)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;
}

void TestAVLTree3()
{

	vector<int> v{ 25059,14777,14692,14409,18330,9370,8178,7509,9114 };
	v.reserve(9);
	int j = 1;
	size_t begin2 = clock();
	RBTree<int, int> t;

	for (int i = 0; i < v.size(); ++i)
	{
		if (i == v.size() - 1)
		{
			t.Insert(make_pair(v[i], v[i]));
		}
		cout << j++ << endl;
		cout << v[i] << endl;
		t.Insert(make_pair(v[i], v[i]));
	}

	size_t end2 = clock();

	cout << "insert:" << end2 - begin2 << endl;
	cout << t.IsBalance() << endl;
	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;

	size_t begin1 = clock();
	//确定在的值
	for (auto e : v)
	{
		t.Find(e);
	}

	//随机值
	for (size_t i = 0; i < v.size(); ++i)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;
}
砖筑
关注
  • 17
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树详解
09-02
红黑树详解（带目录源码） 本文适合那些有对二叉树有一定的基础，并且熟悉C语言的读者。本文最主要的参考资料是《Introduction to Algorithms 3rd Edition》。
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树...
红黑树527378231
06-06
红黑树527378231
C++笔记5•内存管理•
qq_64446190的博客
08-12 699
内存管理
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1190
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
C语言断言进阶篇：全面总结与实战技巧
极客代码
08-10 435
断言是一种用于验证程序中某个条件是否为真的语句。如果条件为假，程序会触发一个错误，通常会导致程序终止。断言主要用于开发和测试阶段，以帮助开发者发现和修正错误。在某些情况下，默认的assert宏可能无法满足我们的需求。if (!abort();= NULL);在这个自定义断言宏中，我们输出了更多的错误信息，包括失败的断言表达式、函数名、文件名和行号，方便我们定位错误。本文系统且全面地总结了C语言中的断言机制，包括断言的定义、作用、实现以及在实战中的运用。
如何对open62541.h/open62541.c的UA_Client进行状态（在线/掉线）监控
joyopirate的博客
08-12 139
可以发现，我们可以对UA_ClientConfig中的stateCallback进行赋值，也就是注册一个状态回调函数，从而获取客户端的状态变化。上位机这边会定时对PLC的某个opcua变量进行写操作。目前在利用open62541.h/open62541.c编写了一个与PLC进行OPCUA通讯的上位机程序。这个opcua库对多线程的处理比较差，很容易造成冲突。有没有什么办法可以监控client的状态，了解其是什么时候掉线，掉线了我就不写就行了。幸亏，是有这么一个回调函数的，参考官方的例子。
Qt/C++最新地图组件发布/历时半年重构/同时支持各种地图内核/包括百度高德腾讯天地图
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
08-06 1647
最近花了半年时间，专门重构了整个地图组件，之前写的比较粗糙，有点为了完成功能而做的，没有考虑太多拓展性和易用性。这套地图自检这几年大量的实际项目和用户使用下来，反馈了不少很好的建议和意见，经过这几年的整理，刚好趁着近期经济下行严重，抽出时间把整个地图组件重构一下，首要的任务就是搞个地图基类，然后子类分别实现不同地图的具体功能。
C++_基本语法笔记_继承和多态
qq_45629864的博客
08-13 324
思想与Java差不多。
C++ 知识点（长期更新）
weixin_51332735的博客
08-09 2037
必知必会
C语言家教记录（三）
C_eeking的博客
08-08 543
本次授课讲述第五章和第六章内容，关键点：选择和循环
矩阵转置（c语言）
scy2429828663的博客
08-09 786
int m = 0;int a = 0;//输入 n m//将数据存储在arr上//输入 aj < n;j++)i < m;i++)//转置i < m;i++)j < n;
c++八股之语法篇
最新发布
zhangqiling
08-13 506
编译阶段define是在编译的预处理阶段起作用，const是在编译、运行时候起作用安全性define只作替换，不作类型的检查和计算，也不求解，容易产生错误。一般加括号包裹住每一个部分，不然很容易出错const常量有数据类型，编译器可以对其进行类型安全检查内存占用define只是将宏名称进行替换，在内存中会产生多份相同的备份。const在程序运行中只有一份备份，且可以执行常量折叠，能将复杂的表达式计算出结果放入常量表宏替换发生在编译阶段之前，属于文本插入替换；const作用于发生编译过程中。
Protobuf：原理、用法与 C++ 实践
weixin_73567058的博客
08-10 846
在当今的软件开发领域，高效的数据序列化和通信协议是构建高性能、可扩展系统的关键。Protobuf（Protocol Buffers）作为一种流行的开源序列化框架，正因其出色的性能、简洁的语法和跨语言支持而备受青睐。本文将深入探讨 Protobuf 的原理和用法，并通过 C++ 代码进行实际操作演示。
C++ Poco框架判断请求方式是GET还是POST
jiexijihe945的博客
08-09 254
作为服务器开发者GET和POST等Method还是要区分的，不同的请求方法要走不同的逻辑。这篇文章很简短但是基于另一篇文章，如果你已经了解Poco了就不用看了。手把手教你使用Poco框架开发服务器应用1、看似简单的一个小函数却是决定成败的关键。
小C的数学（math）
m0_73926005的博客
08-09 488
这一天，他的数学老师给了一道题：给定正整数 a，以及给定一个区间 [b, c]，其中 b, c 均为整数（b, c 保证非负）。寻找所有合法的 x，满足 b ≤ x ≤ c，并且 a 能够整除 x，即 x 除以 a的余数为 0。对于 100% 的数据：0 < a ≤ 10^9，0 ≤ b ≤ c ≤ 10^18。对于 40% 的数据：0 < a ≤ 10^3，0 ≤ b ≤ c ≤ 10^3；对于 70% 的数据：0 < a ≤ 10^7，0 ≤ b ≤ c ≤ 10^7；仅一行一个数，表示答案。
【C++ 第十章】继承
唯有忍受别人不能忍受的，才能享受别人不能享受的
08-10 882
【万字精华讲解】【面试题】继承的概念和定义格式、基类与派生类、继承的作用域、派生类的默认成员函数、继承的友元和静态成员、菱形继承和虚拟继承、继承的总结与反思
【C总集篇】第一章 认识C语言
铁匠匠匠的博客
08-08 306
【代码】【C总集篇】第一章 认识C语言。
C语言：qsort详解
zm3rttqs9f的博客
08-05 1318
在上一篇文章我们大致的了解了回调函数的用法和作用，在这一篇让我们来了解一下在回调函数qsort的使用吧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值