红黑树介绍与模拟实现（insert+颜色调整精美图示超详解哦）

红黑树

  • 引言
  • 红黑树的介绍
  • 实现
    • 结点类
    • insert
      • 搜索插入位置
      • 插入
      • 调整
        • 当parent为gparent的左子结点
        • 当parent为gparent的右子结点
  • 参考源码
  • 测试红黑树是否合格
  • 总结

引言

在上一篇文章中我们认识了高度平衡的平衡二叉树AVL树：戳我看AVL树详解哦
（关于旋转调整的部分，在AVL树的时候已经详细介绍过了，如果大家对旋转调平衡的部分有疑惑的话，请移步至AVL树的详解）

由于AVL树的高度平衡，其平均搜索时间复杂度几乎可以达到严格的O(logN)。同样也因为平衡的程度很高，在维护平衡上时间的花费对于搜索上时间的提升是得不偿失的。
大多数情况下，我们并不需要很高的平衡程度，只需要达成一种接近平衡的状态，搜索的平均时间复杂度基本达到O(logN)即可。 红黑树就是这样的一种结构，它的最高子树的高度小于等于最低子树的二倍。通过减少调平衡时的时间成本来提高效率：

红黑树的介绍

红黑树是平衡二叉树的一种，他在满足二叉搜索树特性的基础上，给每个结点增加了一个颜色属性，包括Red与Black；并要求从根节点到一个叶子结点形成的任意一条路径中，通过对结点颜色的限制规则，没有任何一条路径回比其他的路径长一倍：
在这里插入图片描述
（红黑圣诞树）

对于红黑树结点颜色的限制规则如下：

  • 每个结点的颜色只有红色或黑色两种；
  • 根结点的颜色一定是黑色的；
  • 如果某一个结点的颜色是红色的，它的两个孩子结点的颜色一定是黑色（即不存在两个连续的红色结点）；
  • 对于任一结点，到叶子结点的任一路径上，包含的黑色结点的数量一定相等；
  • 叶子结点一定是黑色的（这里的叶子结点直最后的nullptr）

当满足上面的所有规则时，根节点到叶子结点的任一路径就都不可能比其他路径长一倍。由于不存在连续的红色结点，所以当黑色结点的数量 n 一定时，最长路径的长度为2 * n，最短路径的长度为 n ，所以不可能相差一倍以上。这样就达成了一种相对平衡的状态，并不需要经常去旋转调平了。

实现

红黑树的实现，在之前的二叉搜索树上增加了结点的颜色，以及对于结点的颜色调整的部分；
在本篇文章中依旧实现 K-V的模式 的树， 并且以非递归实现insert；
为防止命名冲突，将实现放在我们的命名空间qqq中：

结点的颜色我们使用 枚举常量enum Color 来表示；

RBTree是一个类模板，有两个模板参数，即K与V，表示其中存储的索引类型与值类型；
成员变量类型为Node*（由结点类RBTreeNode重命名），表示根结点的指针：

 //基本的代码结构
namespace qqq
{
	enum Color //枚举常量表示颜色
	{
		RED,
		BLUCK
	};

	template<class K, class V>
	struct RBTreeNode  //结点类
	{};

	template<class K, class V>
	class RBTree  //红黑树
	{
		typedef RBTreeNode<K, V> Node;
	public:
		bool insert(const pair<K, V>& kv)
		{}
	protected:
		Node* _root = nullptr;
	};
}

结点类

首先，对红黑树的结点进行实现：

RBTreeNode是也一个类模板， 两个模板参数同样为K与V，表示索引与值的类型；
在结点中储存数据的结构为pair，其中first为K类型，second为V类型；

成员变量包括结点中的数据 _kv；
指向父亲结点的指针 _parent；
指向左右孩子结点的指针 _left 与 _right；
表示结点颜色的枚举常量 _col：

template<class K, class V>
struct RBTreeNode  //结点类
{
	pair<K, V> _kv;
	RBTreeNode<K, V>* _parent;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	Color _col;
};

结点类的构造函数
我们需要实现一个默认构造函数：
参数类型为const pair<K, V>，缺省值为一个pair<K, V>的匿名对象；
对于父子结点的指针，在初始化列表中初始化为nullptr即可；
对于结点的颜色，在初始化列表中初始化为RED（要保证每条路上黑色结点的个数相等，就必须初始化为红色）：

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

insert

红黑树的insert分为两个部分，即搜索并插入以及调整使其满足红黑树的性质：

搜索插入位置

  • 与二叉搜索树类似，搜索并插入时，首先用要插入的pair对象创建一个新结点newnode；
  • 与此同时，使用结点指针 cur来记录当前位置 ，parent来记录cur的父结点，便于后面插入；
  • 然后 while循环向下查找 插入的位置：当newnode小于cur的元素时，向左查找，当newnode大于cur的元素时，向右查找，相等时即该元素已经存在，返回false；
  • 当cur为nullptr时，表示找到了插入的位置，循环终止：
// 部分代码：搜索插入位置 //
Node* newnode = new Node(kv);
Node* parent = nullptr;
Node* cur = _root;

while (cur != nullptr) //搜索
{
	if (newnode->_kv.first > cur->_kv.first)
	{
		parent = cur;
		cur = parent->_right;
	}
	else if (newnode->_kv.first < cur->_kv.first)
	{
		parent = cur;
		cur = parent->_left;
	}
	else  //相等即插入失败
	{
		return false;
	}
}

插入

  • 将newnode插入红黑树即将newnode与parent链接，这时就需要判断parent是否为空；
  • 当parent为空时，即cur就是根节点_root，即newnode是这棵红黑树中的第一个结点，将 其赋值给_root 即可；
  • 当parent不为空时， 还需要判断cur位于parent的左边还是右边，然后再插入：

在这里插入图片描述

//  局部代码：插入newnode //
if (parent == nullptr) //插入
{
	_root = newnode;
}
else if (newnode->_kv.first < parent->_kv.first)
{
	parent->_left = newnode;
	newnode->_parent = parent;
	cur = newnode;
}
else
{
	parent->_right = newnode;
	newnode->_parent = parent;
	cur = newnode;
}

调整

在完成插入后，首先需要判断的是parent指针的状态：

  • 当parent为空时，表明当前结点为根结点，将其颜色改为BLACK即可调整完毕；
  • 当parent指向结点的颜色为BLACK 时，如果是在刚插入时，新插入的结点颜色为RED，不会影响该路径的黑色节点个数，所以不再需要调整。如果是在向上调整的过程中parent指向的结点为BLACK，也意味着整棵树调整结束了（这一点在后面的调整部分会详细介绍）；
  • 除了上面不用调整的两种情况外，其余的情况，即 parent指向的结点存在且为RED 的情况就需要进行调整了。调整是自下而上的，循环向上调整，直到 parent为空或parent指向的结点为BLACK时循环结束，调整完成
// 部分代码：自下而上调整的循环框架 //
while (parent != nullptr && parent->_col != BLUCK) 
{}

开始调整时首先对parent为gparent（cur的祖父结点）的左子结点还是右子结点做一分类讨论（当parent不为黑时，由于根结点必须为黑，所以parent不是根结点，所以gparent一定存在）：

当parent为gparent的左子结点

当parent为gparent的左子结点时，我们首先要考察cur叔叔结点的情况：

  • 当cur的叔叔结点为RED 时，不需要进行旋转调整，只需要将gparent指向结点设置为RED，将parent和cur的叔叔结点全部设置为BLACK即可：
    由于在调整完颜色后，gparent指向结点颜色就为RED了，这时如果gparent父结点的颜色正好为红，就出现了连续的两个红色结点。所以需要将cur向上移动两个结点，再对其parent指向的结点继续进行判断：
    在这里插入图片描述

  • 当cur的叔叔结点为BLACK或不存在时，就需要进行旋转调整了：
    旋转的逻辑与之前AVL树类似，当cur位于parent的左边时，即左左——单次右旋：
    在这里插入图片描述
    当cur位于parent的右边时，即左右——左右双旋：
    在这里插入图片描述
    在这里插入图片描述
    旋转调整后将gparent指向结点设置为RED，将子树顶部的结点设置为BLACK 即可（parent指向的结点或cur指向的结点）：
    在这里插入图片描述

经过旋转后的红黑树，子树顶部的颜色一定为黑色，再向上也就不会存在两个连续的红色结点的问题了，所以旋转之后直接终止循环即可。

需要注意的是：叔叔是黑色结点的情况一定是出现在调整过程中发生的，当叔叔结点为黑色时，cur下的路径中一定存在着与gparent右子树中黑色结点相同个数的黑色结点，parent下的路径中同样也存在着相同数目的黑色结点，这样在旋转调平衡后，这棵子树中的所有路径中的黑色结点数目与之前是不变的。

//部分代码：当parent为gparent左子结点的情况
if (parent == gparent->_left)   
{
	if (gparent->_right == nullptr || gparent->_right->_col == BLUCK)  //1.叔叔结点不存在或为黑，需要旋转并调色
	{
		if (cur == parent->_left)//左左->单次右旋
		{
			RotateR(gparent);
			parent->_col = BLUCK;
			gparent->_col = RED;
		}
		else//左右->左旋+右旋
		{
			RotateL(parent);
			RotateR(gparent);

			cur->_col = BLUCK;
			gparent->_col = RED;
		}
		break; //通过旋转调整后，该子树的根结点一定是黑，所以可以直接结束循环
	}
	else if (gparent->_right->_col == RED)  //2.叔叔结点为红，通过调色即可实现红黑树
	{
		//调色
		parent->_col = BLUCK;
		gparent->_right->_col = BLUCK;
		gparent->_col = RED;
		//继续向上
		cur = gparent;
		parent = cur->_parent;
	}
	else
	{
		assert(0);
	}
}
当parent为gparent的右子结点

当parent为gparent的右子结点时，与上面的情况一致，只是左右对调了，所以这里只给出图示与代码（如果在这种情况下遇到了问题，希望你在上面的情况中能够找到答案）：

  • 叔叔结点为RED，仅调整颜色：
    在这里插入图片描述

  • 叔叔结点为BLACK或不存在，左单旋或右左双旋:
    左单旋：
    在这里插入图片描述
    右左双旋：
    在这里插入图片描述在这里插入图片描述
    旋转后调整颜色：
    在这里插入图片描述

旋转后子树顶部的结点一定为BLACK，所以直接break即可。

//部分代码：当parent为gparent右子结点的情况 //
else //parent == gparent->_right
{
	if (gparent->_left == nullptr || gparent->_left->_col == BLUCK)  //1.叔叔结点不存在或为黑，需要旋转并调色
	{
		if (cur == parent->_right)//右右->单次左旋
		{
			RotateL(gparent);
			parent->_col = BLUCK;
			gparent->_col = RED;
		}
		else//右左->右旋+左旋
		{
			RotateR(parent);
			RotateL(gparent);

			cur->_col = BLUCK;
			gparent->_col = RED;
		}
		break; //通过旋转调整后，该子树的根结点一定是黑，所以可以直接结束循环
	}
	else if (gparent->_left->_col == RED)  //2.叔叔结点为红，通过调色即可实现红黑树
	{
		//调色
		parent->_col = BLUCK;
		gparent->_left->_col = BLUCK;
		gparent->_col = RED;
		//继续向上
		cur = gparent;
		parent = cur->_parent;
	}
	else
	{
		assert(0);
	}
}

在while循环调整结束之后，再将根结点_root的颜色改为BLACK，统一做处理（insert的整体代码在这里就不做展示了，大家跳转至参考源码部分查看即可）。

参考源码

namespace qqq
{
	enum Color //枚举常量表示颜色
	{
		RED,
		BLUCK
	};

	template<class K, class V>
	struct RBTreeNode  //结点类
	{
		pair<K, V> _kv;
		RBTreeNode<K, V>* _parent;
		RBTreeNode<K, V>* _left;
		RBTreeNode<K, V>* _right;
		Color _col;

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

	template<class K, class V>
	class RBTree  //红黑树
	{
		typedef RBTreeNode<K, V> Node;

	public:
		bool insert(const pair<K, V>& kv)
		{ 
			//先插入
			Node* newnode = new Node(kv);
			Node* parent = nullptr;
			Node* cur = _root;

			while (cur != nullptr) //搜索
			{
				if (newnode->_kv.first > cur->_kv.first)
				{
					parent = cur;
					cur = parent->_right;
				}
				else if (newnode->_kv.first < cur->_kv.first)
				{
					parent = cur;
					cur = parent->_left;
				}
				else  //相等即插入失败
				{
					return false;
				}
			}
			if (parent == nullptr) //插入
			{
				_root = newnode;
			}
			else if (newnode->_kv.first < parent->_kv.first)
			{
				parent->_left = newnode;
				newnode->_parent = parent;
				cur = newnode;
			}
			else
			{
				parent->_right = newnode;
				newnode->_parent = parent;
				cur = newnode;
			}

			//调整颜色以及旋转使满足红黑树
			while (parent != nullptr && parent->_col != BLUCK) //当parent不为黑时，由于根结点必须为黑，所以parent不是根结点，所以gparent一定存在
			{
				Node* gparent = parent->_parent;

				if (parent == gparent->_left)   
				{
					if (gparent->_right == nullptr || gparent->_right->_col == BLUCK)  //1.叔叔结点不存在或为黑，需要旋转并调色
					{
						if (cur == parent->_left)//左左->单次右旋
						{
							RotateR(gparent);
							parent->_col = BLUCK;
							gparent->_col = RED;
						}
						else//左右->左旋+右旋
						{
							RotateL(parent);
							RotateR(gparent);

							cur->_col = BLUCK;
							gparent->_col = RED;
						}
						break; //通过旋转调整后，该子树的根结点一定是黑，所以可以直接结束循环
					}
					else if (gparent->_right->_col == RED)  //2.叔叔结点为红，通过调色即可实现红黑树
					{
						//调色
						parent->_col = BLUCK;
						gparent->_right->_col = BLUCK;
						gparent->_col = RED;
						//继续向上
						cur = gparent;
						parent = cur->_parent;
					}
					else
					{
						assert(0);
					}
				}
				else
				{
					if (gparent->_left == nullptr || gparent->_left->_col == BLUCK)  //1.叔叔结点不存在或为黑，需要旋转并调色
					{
						if (cur == parent->_right)//右右->单次左旋
						{
							RotateL(gparent);
							parent->_col = BLUCK;
							gparent->_col = RED;
						}
						else//右左->右旋+左旋
						{
							RotateR(parent);
							RotateL(gparent);

							cur->_col = BLUCK;
							gparent->_col = RED;
						}
						break; //通过旋转调整后，该子树的根结点一定是黑，所以可以直接结束循环
					}
					else if (gparent->_left->_col == RED)  //2.叔叔结点为红，通过调色即可实现红黑树
					{
						//调色
						parent->_col = BLUCK;
						gparent->_left->_col = BLUCK;
						gparent->_col = RED;
						//继续向上
						cur = gparent;
						parent = cur->_parent;
					}
					else
					{
						assert(0);
					}
				}
			}
			
			_root->_col = BLUCK;
			return true;
		}
		
		void RotateL(Node* parent)
		{
			Node* gparent = parent->_parent;
			Node* cur = parent->_right;
			Node* curleft = cur->_left;

			parent->_right = curleft;
			if (curleft != nullptr)
			{
				curleft->_parent = parent;
			}

			cur->_left = parent;
			parent->_parent = cur;

			cur->_parent = gparent;
			if (gparent == nullptr)
			{
				_root = cur;
			}
			else
			{
				if (cur->_kv.first < gparent->_kv.first)
				{
					gparent->_left = cur;
				}
				else
				{
					gparent->_right = cur;
				}
			}
		}
		void RotateR(Node* parent)
		{
			Node* gparent = parent->_parent;
			Node* cur = parent->_left;
			Node* curright = cur->_right;

			parent->_left = curright;
			if (curright != nullptr)
			{
				curright->_parent = parent;
			}

			cur->_right = parent;
			parent->_parent = cur;

			cur->_parent = gparent;
			if (gparent == nullptr)
			{
				_root = cur;
			}
			else
			{
				if (cur->_kv.first < gparent->_kv.first)
				{
					gparent->_left = cur;
				}
				else
				{
					gparent->_right = cur;
				}
			}
		}

		bool isRBTree()
		{
			return isRBTree(_root);
		}

	protected:
		Node* _root = nullptr;

		bool checkColor(Node* root, int countBluck, int& baseBluck) //计算黑结点数量与红结点连续是否满足条件
		{
			if (root == nullptr)
			{
				if (baseBluck == countBluck)
				{
					return true;
				}
				return false;
			}

			if (root->_col == RED && root->_parent != nullptr && root->_parent->_col == RED)
			{
				return false;
			}

			if (root->_col == BLUCK)
			{
				countBluck++;
			}
			return checkColor(root->_left, countBluck, baseBluck) && checkColor(root->_right, countBluck, baseBluck);
		}

		bool isRBTree(Node* root)
		{
			if (root == nullptr)
				return true;
			if (root->_col == RED)
				return false;

			//先计算一条路径中的黑色结点数量
			int baseBluck = 0;
			Node* cur = root;
			while (cur != nullptr)
			{
				if (cur->_col == BLUCK)
				{
					++baseBluck;
				}
				cur = cur->_right;
			}

			return checkColor(root, 0, baseBluck);
		}
	};
}

测试红黑树是否合格

在写完红黑树的insert之后，我们可以再编写一个测试模块来测试一棵树是否满足红黑树的特性：

我们其实只需要判断两点即可：

  • 任一路径上的黑色结点个数是否相等；
  • 是否存在连续的两个红色结点。

我们使用递归的方式来判断：

判断任一路径上的黑色结点个数是否相等时，必须要先计算某条路径上的黑色结点个数，可以通过 while循环计算最右侧一条路径上的黑色结点个数。将cur从_root开始一直向右子节点遍历即可，当cur为空时即该路径结束，终止循环。

然后使用checkColor函数（参数为当前结点指针Node*，计算中的当前路径黑色结点个数int，以及先前计算的最外层黑色结点个数int ）递归计算每条路径上的黑色结点个数，顺便判断是否存在连续的红色结点。
在递归过程中：
当_root为空时，即当前路径已经结束，判断countBluck与baseBlack的值是否相等，若相等返回true，否则返回false；
若当前结点为红色，则判断其父结点是否为红色，是就返回false；
若当前结点为黑色，countBluck加1，并继续向左右子结点递归，返回左子结点的结果&&右子结点的结果:
在这里插入图片描述

测试红黑树是否合格的代码这里就不赘述了，大家可以在参考源码部分查找。这里来展示一下测试结果：

namespace qqq
{
	void testfunc()
	{
		const int N = 10000000;
		vector<int> v;
		v.reserve(N);
		srand(time(0));

		for (size_t i = 0; i < N; i++)
		{
			v.push_back(i);
		}

		RBTree<int, int> rbt;
		for (auto e : v)
		{
			rbt.insert(make_pair(e, e));
			cout << "insert:" << e << "->" << rbt.isRBTree() << endl;
		}
		cout << rbt.isRBTree() << endl;
	}
}

int main()
{
	qqq::testfunc();
	return 0;
}

在这里插入图片描述
因为这段测试代码中，存在大量I/O，所以运行速度很慢，大家可以将cout注释掉，只打印最后的结果。

总结

到此，关于红黑树的知识就介绍完了
在接下来的文章中，将会对红黑树进行封装，即map与set，尽情期待哦

如果大家认为我对某一部分没有介绍清楚或者某一部分出了问题，欢迎大家在评论区提出

如果本文对你有帮助，希望一键三连哦

希望与大家共同进步哦

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/516355.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

springboot 项目整合easy-captcha验证码功能

springboot 项目整合easy-captcha验证码功能

效果 1、验证码使用easy-captcha,在pom文件增加依赖 <!-- google 验证码 --><dependency><groupId>com.github.whvcse</groupId><artifactId>easy-captcha</artifactId></dependency> 2、增加获取kaptcha的ctrl package com.*.*.s…
阅读更多...
AcWing 786. 第k个数——算法基础课题解

AcWing 786. 第k个数——算法基础课题解

AcWing 786. 第k个数 文章目录 题目描述思路CGo 题目描述 给定一个长度为 n的整数数列&#xff0c;以及一个整数 k&#xff0c;请用快速选择算法求出数列从小到大排序后的第 k 个数。 输入格式 第一行包含两个整数 n 和 k。 第二行包含 n 个整数&#xff08;所有整数均在 …
阅读更多...
韩顺平 | 零基础快速学Python

韩顺平 | 零基础快速学Python

环境准备 开发工具&#xff1a;IDLE、Pycharm、Sublime Text、Eric 、文本编辑器&#xff08;记事本/editplus/notepad&#xff09; Python特点&#xff1a;既支持面向过程OOP、也支持面向对象编程&#xff1b;具有解释性&#xff0c;不需要编程二进制代码&#xff0c;可以直…
阅读更多...
MySQL 导入库/建表时/出现乱码

MySQL 导入库/建表时/出现乱码

问题描述&#xff1a; 新建不久的项目在使用Navicat for MySQL进行查看数据&#xff0c;发现表中注释的部分乱码&#xff0c;但是项目中获取的数据使用不会。 猜测因为是数据库编码和项目中使用的不一样&#xff0c;又因为项目的连接语句定义了需要编码&#xff0c;故项目运行…
阅读更多...
特征融合篇 | 结合内容引导注意力 DEA-Net 思想 实现双主干特征融合新方法 | IEEE TIP 2024

特征融合篇 | 结合内容引导注意力 DEA-Net 思想 实现双主干特征融合新方法 | IEEE TIP 2024

本篇改进已集成到 YOLOv8-Magic 框架。 摘要—单幅图像去雾是一个具有挑战性的不适定问题，它从观察到的雾化图像中估计潜在的无雾图像。一些现有的基于深度学习的方法致力于通过增加卷积的深度或宽度来改善模型性能。卷积神经网络（CNN）结构的学习能力仍然未被充分探索。本文…
阅读更多...
AI大模型与网球运动结合的应用场景及案例分析

AI大模型与网球运动结合的应用场景及案例分析

AI大模型与网球运动结合的未来前景是广阔的&#xff0c;它不仅能够提升运动员的训练和比赛表现&#xff0c;还能改善教练的策略制定、增强观众的观赛体验以及优化网球赛事的管理。以下是几个具体的应用场景&#xff1a; 1. 运动员技能和表现分析 AI大模型可以通过分析高速摄像…
阅读更多...
8.list容器的使用

8.list容器的使用

文章目录 list容器1.构造函数代码工程运行结果 2.赋值和交换代码工程运行结果 3.大小操作代码工程运行结果 4.插入和删除代码工程运行结果 5.数据存取工程代码运行结果 6.反转和排序代码工程运行结果 list容器 1.构造函数 /*1.默认构造-无参构造*/ /*2.通过区间的方式进行构造…
阅读更多...
FPGA实现CLAHE算法(Verilog)

FPGA实现CLAHE算法(Verilog)

在介绍CLAHE算法之前必须要先提一下直方图均衡化&#xff0c;直方图均衡化算法是一种常见的图像增强算法&#xff0c;可以让像素的亮度分配的更加均匀从而获得一个比较好的观察效果。 左边是原图&#xff0c;右边是经过直方图均衡化后图&#xff0c;可以看到肋骨什么的可以更…
阅读更多...
鸿蒙应用开发-ArkUI 计算器

鸿蒙应用开发-ArkUI 计算器

一、效果图 在正式介绍ArkUI计算器应用之前&#xff0c;我们先来一睹其风采。效果图上的计算器界面简洁大方&#xff0c;每个按钮都经过精心设计&#xff0c;颜色搭配恰到好处&#xff0c;使得整体界面既美观又实用。数字、运算符等按钮排列整齐&#xff0c;用户可以一目了然地…
阅读更多...
鸽哒言讯独家最新im即时通讯系统双端源码下载 （中越双语）带安卓未封装、苹果未封装、PC端（全开源）+部署教程

鸽哒言讯独家最新im即时通讯系统双端源码下载 （中越双语）带安卓未封装、苹果未封装、PC端（全开源）+部署教程

独家最新im即时通讯系统双端源码下载 &#xff08;中越双语&#xff09;带安卓未封装、苹果未封装、PC端&#xff08;全开源&#xff09;部署教程鸽哒IM即时通讯系统是一款类似于weixin的即时通讯软件&#xff0c;具有独立开发的特点。与网络其他聊天软件相比&#xff0c;即时聊…
阅读更多...
HTMLCSSJS

HTMLCSSJS

HTML基本结构 <html><head><title>标题</title></head><body>页面内容</body> </html> html是一棵DOM树, html是根标签, head和body是兄弟标签, body包括内容相关, head包含对内容的编写相关, title 与标题有关.类似html这种…
阅读更多...
Word中插入Endnote参考文献时显示乱码

Word中插入Endnote参考文献时显示乱码

近期在写文章需要插入参考文献&#xff0c;使用Endnote插入时显示乱码&#xff0c;如下图所示&#xff1a; 文章末尾显示{ADDIN EN REFILIST } 解决方法 在网上找了诸多方法尝试也没有解决&#xff0c;最终找到一篇博客介绍了一种方法&#xff1a; word选项—高级&#xff1…
阅读更多...
16.springboot项目下使用事务（springboot-016-transaction）

16.springboot项目下使用事务（springboot-016-transaction）

事务是一个完整的功能&#xff0c;也叫作是一个完整的业务 事务只跟什么SQL语句有关&#xff1f;事务只跟DML语句有关系&#xff1a;增删改 DML,DQL,DDL,TCL,DCL 首先添加两个依赖以及MyBatis代码自动生成插件 <!--MySql驱动--><dependency><groupId>mysql…
阅读更多...
【C++】探索C++中的类与对象（上）

【C++】探索C++中的类与对象（上）

​​ &#x1f331;博客主页&#xff1a;青竹雾色间. &#x1f618;博客制作不易欢迎各位&#x1f44d;点赞⭐收藏➕关注 ✨人生如寄&#xff0c;多忧何为 ✨ C是一种强大的编程语言&#xff0c;其面向对象的特性使得代码结构更加清晰、易于维护和扩展。在C中&#xff0c;类与…
阅读更多...
Elasticsearch 压测实践总结

Elasticsearch 压测实践总结

背景 搜索、ES运维场景离不开压力测试。 1.宿主机层面变更&#xff1a;参数调优 & 配置调整 & 硬件升级2.集群层面变更&#xff1a;参数调优3.索引层面变更&#xff1a;mapping调整 当然还有使用层面变更&#xff0c;使用API调优&#xff08;不属于该文章的讨论范围…
阅读更多...
京东获得JD商品详情 API 接口（jd.item_get）的详细使用说明，包括如何通过该接口获取商品的基本信息，包括名称、品牌、产地、规格参数等

京东获得JD商品详情 API 接口（jd.item_get）的详细使用说明，包括如何通过该接口获取商品的基本信息，包括名称、品牌、产地、规格参数等

通过调用京东商品详情API接口&#xff0c;开发者可以获取商品的基本信息&#xff0c;如名称、品牌、产地、规格参数等。此外&#xff0c;还可以获取商品价格信息&#xff0c;包括原价、促销价和活动信息等。同时&#xff0c;该接口还支持获取商品的销量、评价、图片、描述等详细…
阅读更多...
MySQL8.0.36 GTID主从同步失败排查

MySQL8.0.36 GTID主从同步失败排查

报错信息&#xff1a; Last_SQL_Error: Coordinator stopped because there were error(s) in the worker(s). The most recent failure being: Worker 1 failed executing transaction 6f577885-e5d0-11ee-a94a-0242c0a80067:1 at source log 7364ffd6441c-bin.000006, end_lo…
阅读更多...
C语言 | Leetcode C语言题解之3题无重复字符的最长子串

C语言 | Leetcode C语言题解之3题无重复字符的最长子串

题目&#xff1a; 题解&#xff1a; int lengthOfLongestSubstring(char * s) {//类似于hash的思想//滑动窗口维护int left 0;int right 0;int max 0;int i,j;int len strlen(s);int haveSameChar 0;for(i 0; i < len ; i ){if(left < right){ //检测是否出现重…
阅读更多...
编译好的C++应用程序拷贝到其它电脑，提示dll未找到依赖项的解决方法。

编译好的C++应用程序拷贝到其它电脑，提示dll未找到依赖项的解决方法。

编译好的C应用程序拷贝到其它电脑上&#xff0c;运行时出现提示dll未找到依赖项。 由于dll依赖于其它dll&#xff0c;在开发用电脑上的环境不能完全与其它电脑相同。 解决办法是找到调用到的dll依赖的所有dll&#xff0c;拷贝到运行目录下。 在开发电脑上&#xff1a; 1、开…
阅读更多...
7.stack容器的使用

7.stack容器的使用

文章目录 stack容器常用接口代码工程运行结果 stack容器 常用接口 /*1.push - 入栈*/ /*2.top - 查看栈顶元素*/ /*3.pop - 出栈*/代码工程 #define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<stack>using namespace std;/*1.push - 入栈*/ /*2.top…
阅读更多...
最新文章

Copyright @ 2022~2023