数据结构——红黑树详解

一、红黑树的定义

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。（说它是接近平衡因为它并没有像AVL树的平衡因子的概念，它只是靠着满足红黑节点的5条性质来维持一种接近平衡的结构，进而提升整体的性能）

 红黑树的性质：

1. 每个结点不是红色就是黑色。

2. 根节点是黑色的。

3. 如果一个节点是红色的，则它的两个孩子结点是黑色的。

4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点。

5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)。

为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

由性质4可知，红黑树的根节点到其叶子结点的所有路径上黑色节点的个数相同，那么一条路径上如果没有红色节点，则该路径为最短路径。

由性质3可知，红黑树的红色节点不连续，那么在一条路径上间隔插入红色节点，则该路径为最长路径。

得出结论：最短路径为全黑色节点，最长路径为一黑一红节点。所以，最长路径中节点个数不会超过最短路径节点个数的两倍。最短路径和最长路径可能在一颗红黑树上并不存在，如上图中就不存在最短路径。

二、红黑树的基本操作实现

红黑树同样是二叉查找树的演变，因此红黑树和AVL树一样，查找、遍历操作基本和二叉查找树一样。而红黑树的插入和删除操作与AVL树相比，需要对节点的颜色进行调整，也使用了旋转操作。

红黑树节点定义:

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;
	Colour _col;
	RBTreeNode(const pair<k, v>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

红黑树节点的结构与AVL树节点类似，这里用节点的颜色来替换平衡因子。

2.1 红黑树的插入操作

插入中需要用到的节点概念：

  • parent：父亲节点
  • uncle：叔叔节点（ parent 的兄弟节点）
  • grand：祖父节点（ parent 的父节点）

红黑树的节点有颜色之分，那么新插入节点的颜色是红色还是黑色呢？

当插入节点的颜色是黑色，新节点所在路径上的黑色节点个数+1。要保持每条路径上黑色节点个数相同，需要对其他路径一一调整，这样操作是非常繁琐的。

当插入节点的颜色是红色，所有路径上的黑色节点个数均不变。当新节点的父亲是黑色时，插入新节点，依然符合红黑树性质，无需调整。当新节点的父亲是红色时，进行调整。

得出结论：新插入节点默认颜色为红色。

2.1.1 叔叔节点(uncle)存在且为红

新插入节点cur的父亲为黑，插入后依然符合红黑树性质，无需调整。新插入节点cur的父亲为红，并且爷爷节点(grandparent)为黑（红黑树的红色节点不连续），叔叔节点(uncle)存在且为红。

此时对该子树进行操作，将parent节点变为黑色，grandparent节点变为红色，这样就能保证该子树中每条路径中黑色节点相同，并且没有连续的红色节点。然后更新cur、parent节点，parent = cur->_parent，cur=grandparent，沿插入路径向上调整，直到该树中没有连续的红节点。如下图所示：

2.1.2 叔叔节点(uncle)不存在或存在且为黑

新插入节点cur的父亲为红，并且爷爷节点(grandparent)为黑（红黑树的红色节点不连续），叔叔节点(uncle)不存在或存在且为黑。

在插入cur节点前，该树各路径上黑色节点个数已经不同，不满足红黑树的性质。说明cur节点不是新插入的节点，且cur以前是黑色节点，经过第一种情况的颜色调整后，cur节点变为红色。此时需要旋转操作，并更改颜色。这里不对旋转做详细叙述，参考数据结构——AVL树详解-CSDN博客。

右单旋：当parent节点时grandparent节点的右孩子，且cur节点是parent节点的右孩子

旋转后将grandparent节点变为红色，parent变为黑色。

右单旋：当parent节点时grandparent节点的左孩子，且cur节点是parent节点的左孩子

旋转后将grandparent节点变为红色，parent变为黑色。

左右双旋：当parent节点时grandparent节点的左孩子，且cur节点是parent节点的右孩子

旋转后将grandparent节点变为红色，cur变为黑色。 

右左双旋：当parent节点时grandparent节点的右孩子，且cur节点是parent节点的左孩子

旋转后将grandparent节点变为红色，cur变为黑色。  

插入代码实现具体实现如下：

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
			{
				return false;
			}
		}
		cur = new Node(kv); // 在cur位置插入红色节点
		if (parent->_kv.first < kv.first) {//连接cur节点到红黑树
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//1：当叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}

				else
				{
					//2：叔叔不存在或者存在且为黑，由第一种情况调整而来
					//旋转＋变色
					if (cur == parent->_left)
					{
						//     g
						//   p    u
						// c
						//此时路径上黑色节点不相同，且有连续的红色节点，不满足最长路径是最短路径的两倍
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//     g
						//   p    u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;

				}

			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}

				else
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}

					else {
						//      g
						//   u     p
						//       c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

三、红黑树的验证

红黑树的检测分为两步：

1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)

2. 检测其是否满足红黑树的性质：根节点是否为黑色，各路径黑色节点个数是否相同，红色节点是否连续出现。

bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

先判断根节点，根节点为空或者根节点为红色，直接返回false。按照中序遍历，找到最左路径，遇到黑色节点refBlackNum++,最后得到最左路径的黑色节点个数。调用Check函数，传入根节点和refBlackNum。

bool Check(Node* cur, int blackNum, int refBlackNum)
	{//传blackNum，每次走到黑色节点++，为nullptr回到上一层调用走右子树，此时blackNum还是上一层的值
		if (cur == nullptr) {
			if (refBlackNum != blackNum) {
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		
	}
	if (cur->_col == RED && cur->_parent->_col == RED) {
		cout << "存在连续的红色节点" << endl;
		return false;
	}
	if (cur->_col == BLACK)
		++blackNum;

	return Check(cur->_left, blackNum, refBlackNum) && Check(cur->_right, blackNum, refBlackNum);
}

当cur==nullptr,说明当前路径已走完，判断这条路径黑色节点个数blackNum是否和refBlackNum（标准值）是否相等。不为空时，判断当前节点是否为红色，如果cur为红色，再判断其父亲是否为红色（&&避免判断根节点的parent）。如果是黑色节点，blackNum++，最后递归左子树与右子树。blackNum为传值，每次遇到黑色节点++，为nullptr回到上一层调用遍历右子树，此时blackNum还是上一层的值。

四、红黑树的模拟实现

#define  _CRT_SECURE_NO_WARNINGS
#pragma once
#include<vector>
#include<iostream>
#include<time.h>
using namespace std;

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;
	Colour _col;
	RBTreeNode(const pair<k, v>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

template<class k,class v>
class RBTree
{
	typedef RBTreeNode<k, v> Node;
public:
	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
			{
				return false;
			}
		}
		cur = new Node(kv); // 在cur位置插入红色节点
		if (parent->_kv.first < kv.first) {//连接cur节点到红黑树
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//1：当叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}

				else
				{
					//2：叔叔不存在或者存在且为黑，由第一种情况调整而来
					//旋转＋变色
					if (cur == parent->_left)
					{
						//     g
						//   p    u
						// c
						//此时路径上黑色节点不相同，且有连续的红色节点，不满足最长路径是最短路径的两倍
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//     g
						//   p    u
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;

				}

			}
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}

				else
				{
					// 情况二：叔叔不存在或者存在且为黑
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}

					else {
						//      g
						//   u     p
						//       c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

	void RotateL(Node* parent)//左单旋
	{
		++rotateSize;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		subR->_left = parent;
		Node* ppnode = parent->_parent;//记录parent的父节点
		parent->_parent = subR;
		if (parent == _root)//考虑parent是该树的根节点
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}



	void RotateR(Node* parent)//右单旋
	{
		++rotateSize;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		subL->_right = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

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

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

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

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

	void InOrder()
	{
		_InOrder(_root);
	}

	int GetRotateSize()
	{
		return rotateSize;
	}

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

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

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

	bool IsBalance()
	{
		if (_root && _root->_col == RED)
			return false;

		int refBlackNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;

			cur = cur->_left;
		}

		return Check(_root, 0, refBlackNum);
	}

	bool Check(Node* cur, int blackNum, int refBlackNum)
	{//传blackNum，每次走到黑色节点++，为nullptr回到上一层调用走右子树，此时blackNum还是上一层的值
		if (cur == nullptr) {
			if (refBlackNum != blackNum) {
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		
	}
	if (cur->_col == RED && cur->_parent->_col == RED) {
		cout << "存在连续的红色节点" << endl;
		return false;
	}
	if (cur->_col == BLACK)
		++blackNum;

	return Check(cur->_left, blackNum, refBlackNum) && Check(cur->_right, blackNum, refBlackNum);
}
	private:
		Node* _root = nullptr;
		int rotateSize = 0;
	
};

五、红黑树和AVL树的比较

  1. AVL树的时间复杂度虽然优于红黑树，但是对于现在的计算机，cpu太快，可以忽略性能差异。
  2. 红黑树的插入删除比AVL树更便于控制操作。
  3. 红黑树整体性能略优于AVL树（红黑树旋转情况少于AVL树）。

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

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

相关文章

转专业:集成电路、微电子、电子信息选哪个?

转专业:集成电路、微电子、电子信息选哪个?

目录 集成电路专业 微电子技术专业 电子信息工程专业 综合分析 在考虑转专业到集成电路、微电子或电子信息时&#xff0c;您需要考虑多个因素&#xff0c;包括个人兴趣、专业课程内容、行业前景以及未来就业市场的需求。以下是关于这三个专业的详细分析&#xff0c;以及它们…
阅读更多...
酷开科技智慧AI让酷开系统大显身手！

酷开科技智慧AI让酷开系统大显身手！

时代的浪潮汹涌而至&#xff0c;人工智能作为技术革新和产业变革的重要引擎&#xff0c;正深刻地影响着各行各业。在科技的海洋中&#xff0c;AI技术正逐渐渗透到我们的日常生活中&#xff0c;为我们带来前所未有的便捷和智慧。酷开科技用技术探索智慧AI&#xff0c;别看它只是…
阅读更多...
让六西格玛培训有效的三个步骤，拿走不谢！

让六西格玛培训有效的三个步骤，拿走不谢！

近年来&#xff0c;六西格玛作为一种先进的质量管理方法&#xff0c;被众多企业视为提升产品质量、优化流程、减少浪费的利器。然而&#xff0c;如何使六西格玛培训真正落地生根&#xff0c;发挥出其应有的效果&#xff0c;成为了许多企业关注的焦点。本文&#xff0c;天行健Si…
阅读更多...
Java零基础入门到精通_Day 4

Java零基础入门到精通_Day 4

方法的重载 就是同一个类中的相同方法名的多个方法&#xff0c;但是他们的参数不同&#xff0c;类型不同或者参数个数不同。 &#xff08;与返回值无关&#xff09; package Base_One;public class Base_005 {public static void main(String[] args) {// Main method logic …
阅读更多...
探析Drools规则引擎的工作机制

探析Drools规则引擎的工作机制

目录 一、工作原理 二、工作流程 2.1 初始化环境 2.2 添加规则文件 2.3 编译规则文件 2.4 插入到工作内存 2.5 规则匹配与激活 2.6 规则执行 三、Drools 其他特性 3.1 符合事实 3.2 决策表 3.3 规则生命周期管理 3.4 规则流 四、Rete 算法 一、工作原理 Drools 规则引擎的工…
阅读更多...
如何理解Java注解反射

如何理解Java注解反射

Java 8 中文版 - 在线API手册 - 码工具 什么是注解 ◆Annotation是从JDK5.0开始引入的新技术 ◆Annotation的作用: 不是程序本身&#xff0c;可以对程序作出解释.(这一点和注释(comment)没什么区别) 可以被其他程序(比如:编译器等)读取 Annotation的格式: > 注解是以&quo…
阅读更多...
OSError: Can‘t load tokenizer for ‘bert-base-chinese‘

OSError: Can‘t load tokenizer for ‘bert-base-chinese‘

文章目录 OSError: Cant load tokenizer for bert-base-chinese1.问题描述2.解决办法 OSError: Can’t load tokenizer for ‘bert-base-chinese’ 1.问题描述 使用from_pretrained()函数从预训练的权重中加载模型时报错&#xff1a; OSError: Can’t load tokenizer for ‘…
阅读更多...
数据结构栈和堆列

数据结构栈和堆列

目录 栈&#xff1a; 栈的概念&#xff1a; 栈的实现&#xff1a; 栈接口的实现&#xff1a; 1.初始化栈&#xff1a; 2.入栈&#xff1a; 3.出栈&#xff1a; 4. 获取栈顶元素&#xff1a; 5.获取栈中有效数据的个数&#xff1a; 6.检测栈是否为空&#xff0c;如果为…
阅读更多...
搜索二维矩阵 II - LeetCode 热题 21

搜索二维矩阵 II - LeetCode 热题 21

大家好&#xff01;我是曾续缘&#x1f497; 今天是《LeetCode 热题 100》系列 发车第 21 天 矩阵第 4 题 ❤️点赞 &#x1f44d; 收藏 ⭐再看&#xff0c;养成习惯 搜索二维矩阵 II 编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性&…
阅读更多...
20240402—Qt如何通过动态属性设置按钮样式？

20240402—Qt如何通过动态属性设置按钮样式？

前言 正文 1、点击UI文件 2、选择Bool型或是QString 3、设置后这里出现动态属性 4、这qss文件中绑定该动态属性 QPushButton[PopBlueBtn"PopBlueBtn"]{background-color:#1050B7;color:#FFFFFF;font-size:20px;font-family:Source Han Sans CN;//思源黑体 CNbor…
阅读更多...
Ansys Zemax | 如何将光栅数据从Lumerical导入至OpticStudio（上）

Ansys Zemax | 如何将光栅数据从Lumerical导入至OpticStudio（上）

附件下载 联系工作人员获取附件 本文介绍了一种使用Ansys Zemax OpticStudio和Lumerical RCWA在整个光学系统中精确仿真1D/2D光栅的静态工作流程。将首先简要介绍方法。然后解释有关如何建立系统的详细信息。 本篇内容将分为上下两部分&#xff0c;上部将首先简要介绍方法工…
阅读更多...
01 Python进阶：正则表达式

01 Python进阶：正则表达式

re.match函数 使用 Python 中的 re 模块时&#xff0c;可以通过 re.match() 函数来尝试从字符串的开头匹配一个模式。以下是一个简单的详解和举例&#xff1a; import re# 定义一个正则表达式模式 pattern r^[a-z] # 匹配开头的小写字母序列# 要匹配的字符串 text "h…
阅读更多...
程序的编译、链接过程分析（简洁浓缩版）！

程序的编译、链接过程分析（简洁浓缩版）！

《嵌入式工程师自我修养/C语言》系列——程序的编译、链接过程分析&#xff08;简洁浓缩版&#xff09;&#xff01; 一、程序的编译1.1 预编译指令 pragma1.2 编译过程概述1.3 符号表和重定位表 二、程序的链接2.1 分段组装2.2 符号决议2.2.1 强符号与弱符号2.2.2 GNU编译器的…
阅读更多...
了解与生成火焰图

了解与生成火焰图

目录 一、如何看懂火焰图 1、基本特征 2、基本分类 二、如何生成火焰图 1、捕获调用栈 2、折叠栈 3、转换为 svg 格式 4、展示 svg 一、如何看懂火焰图 1、基本特征 &#xff08;1&#xff09;纵轴&#xff1a;即每一列代表一个调用栈&#xff0c;每一个格子代表一个函…
阅读更多...
智能仓储变革在即，从业者该何去何从？

智能仓储变革在即，从业者该何去何从？

导语 大家好&#xff0c;我是智能仓储物流技术研习社的社长&#xff0c;你的老朋友&#xff0c;老K。行业群 新书《智能物流系统构成与技术实践》 随着2024年的到来&#xff0c;物流和仓储行业正处于一个技术革命的关键时刻。人工智能&#xff08;AI&#xff09;的融入不仅预示…
阅读更多...
【二叉树】Leetcode 437. 路径总和 III【中等】

【二叉树】Leetcode 437. 路径总和 III【中等】

路径总和 III 给定一个二叉树的根节点 root &#xff0c;和一个整数 targetSum &#xff0c;求该二叉树里节点值之和等于 targetSum 的 路径 的数目。 路径 不需要从根节点开始&#xff0c;也不需要在叶子节点结束&#xff0c;但是路径方向必须是向下的&#xff08;只能从父节…
阅读更多...
Zabbix6 - Centos7部署Grafana可视化图形监控系统配置手册手册

Zabbix6 - Centos7部署Grafana可视化图形监控系统配置手册手册

Zabbix6 - Centos7部署Grafana可视化图形监控系统配置手册手册 概述&#xff1a; Grafana是一个开源的数据可视化和监控平台。其特点&#xff1a; 1&#xff09;丰富的可视化显示插件&#xff0c;包括热图、折线图、饼图&#xff0c;表格等&#xff1b; 2&#xff09;支持多数据…
阅读更多...
[源码] Android 上的一些快捷方式，如通知、快捷方式等

[源码] Android 上的一些快捷方式，如通知、快捷方式等

目录 一、通知0. 配置权限1. 测试发送通知代码2. 打开通知设置界面代码3. 前台服务创建常驻通知 二、快捷方式1. 测试添加动态快捷方式代码 三、开发者图块四、桌面小部件 基于jetpack compose 框架的使用代码 一、通知 参见 官方文档 0. 配置权限 <uses-permission andr…
阅读更多...
REST API的指纹验证机制

REST API的指纹验证机制

前端或者客户端涉及数据相关的请求都是不安全的&#xff0c;从某种意义上只能通过一些手段降低请求不被容易使用。本来来介绍一种基于 JWT 的指纹机制。 关于 JWT 令牌机制就不详细介绍了。在 JWT 令牌中包含系统 JWT 指纹可以带来安全改进&#xff0c;而不会给用户带来任何不…
阅读更多...
RocketMQ 消费者源码解读：消费过程、负载原理、顺序消费原理

RocketMQ 消费者源码解读：消费过程、负载原理、顺序消费原理

B站学习地址 上一遍学习了三种常见队列的消费原理&#xff0c;本次我们来从源码的角度来证明上篇中的理论。 1、准备 RocketMQ 版本 <!-- RocketMQ --> <dependency><groupId>org.apache.rocketmq</groupId><artifactId>rocketmq-spring-boot-s…
阅读更多...
最新文章

Copyright @ 2022~2023