C++红黑树详解

news2025/1/28 1:21:57

文章目录

  • 红黑树
    • 概念
    • 规则
    • 为什么最长路径不超过最短路径的二倍？
    • 红黑树的时间复杂度
    • 红黑树的结构
    • 插入
      • 叔叔节点情况的讨论
        • 只变色(叔叔存在且为红)
        • 抽象的情况
        • 变色+单旋（叔叔不存在或叔叔存在且为黑）
        • 变色+双旋（叔叔不存在或叔叔存在且为黑）
  • 判断是不是红黑树
  • 代码

红黑树

概念

红黑树保证了最长的路径不超过最短路径的二倍

规则

  1. 根节点是黑色的
  2. 每个节点不是红色就是黑色
  3. 如果有一个节点是红的，那么它的两个孩子都是黑的，就是说一条路径不会有两个连续的红色节点（不会出现红红，其他情况可以出现红黑，黑黑，黑红）
  4. 对于每个节点到其空节点上的简单路径，每一条路径上都有相同数量的黑色节点

为什么最长路径不超过最短路径的二倍？

  1. 最短路径就是全黑
  2. 最长路径就是一黑一红的组合
  3. 假设每条路径有x个黑色的节点
    最短：x
    最长：2*x
    这是最极端的场景
  4. 其它的场景都在最短和最长之间
    比如下面这幅图：
    最短：3
    最长：4
    最长路径不超过最短路径的2倍
    在这里插入图片描述

路径的条数（要算到走到空的场景）：9条路径
在这里插入图片描述
其它书里可能出现下面的图：
这样是为了计算路径的条数更加方便，防止算错
加了这样的空节点也不违反规则
在这里插入图片描述

红黑树的时间复杂度

假设节点个数为N
用极端的场景来算
红黑树最短路径的高度为：2^h-1 = N, h = log(N+1)
最长路径的高度为：2^2h-1 = N,h = (log(N+1))/2

其实最快可以近似为logN,最慢可以近似为2*logN，
整体上时间复杂度还是logN,只是没有AVL树那么接近logN

红黑树的结构

// 枚举红黑树的颜色
enum Colour
{
	RED,
	BLACK
};

// 按Key/Value的模式实现
template<class K,class V>
class 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)
	{}
};

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


private:
	Node* _root = nullptr;
};

插入

插入红色节点还是黑色节点呢？

  • 插入红色节点可能违反规则3，红色节点的父亲可能是红色节点，父亲是黑色节点就不用管
  • 插入时黑色节点必然会违反规则4，每条路径上都要有相同数量的黑色节点
  1. 按二叉搜索树的规则插入，不违反上面的4条规则
  2. 如果是空树插入，则插入黑色节点。如果是非空树插入，必然插入红色，因为黑色违反规则4
  3. 插入红色节点，如果父亲是黑色节点，不违反规则，插入结束
  4. 插入红色节点，如果父亲是红色节点，违反规则3。
    插入节点c必然是红色，父亲节点p也是红色，因为之前也要遵循红黑树的规则，所以爷爷节点g也要是黑色，是红色之前就违反规则了。所以c,p,g三个节点的颜色是固定的。
    先在关键看叔叔节点u了，u可以是红色，也可以是黑色，所以要分情况讨论叔叔节点的颜色。
    在这里插入图片描述

叔叔节点情况的讨论

只变色(叔叔存在且为红)
  1. c为红，p为红，g为黑，u存在且为红。将p变黑，因为红红违反了规则3，p必须变红。u也变黑，g变红。
  2. 把g当做c继续向上更新，需要继续向上更新是因为如果g的父亲还是红色，就需要继续向上处理；如果g的父亲是黑色，就处理结束；如果g就是整棵树的根，再把g变为黑色。
    在这里插入图片描述
抽象的情况
  1. 叔叔存在且为红，（a和b是抽象出来的子树）a和b要满足下面的模版，爷爷的两个孩子都是红色，才满足只变色
    在这里插入图片描述
  2. 抽象的情况:
    在这里插入图片描述
  3. bh(black height),bh == 0
    在这里插入图片描述
  4. bh == 1
    在这里插入图片描述
  5. bh == 2
    在这里插入图片描述
变色+单旋（叔叔不存在或叔叔存在且为黑）

p,c是红，g是黑，u不存在或者u存在且为黑

  1. u不存在，c只能是新增节点（如果c不是新增节点的话，它只能是之前变色变过来的，那它之前就是黑色，黑色节点的数量就不对）。右旋，把父亲节点变黑，g变红
  2. u存在且为黑，c一定不是新增（如果c是新增，那么新增前，黑色的数量不对），c之前就是黑色的，现在变成了红色，因为进行了变色。右旋，父亲变为黑色，爷爷变为红色
  3. 不用继续往上更新，因为黑黑可以，红黑也可以，就不用管了。
    在这里插入图片描述
变色+双旋（叔叔不存在或叔叔存在且为黑）

p,c是红，g是黑，u不存在或者u存在且为黑

  1. u不存在，c只能是新增节点（如果c不是新增节点的话，它只能是之前变色变过来的，那它之前就是黑色，黑色节点的数量就不对）。
  2. u存在且为黑，c一定不是新增（如果c是新增，那么新增前，黑色的数量不对），c之前就是黑色的，现在变成了红色，因为进行了变色。
  3. 左单旋，然后右单旋，父亲节点不变色，cur节点由红色变成黑色，grandfather节点由黑色变成红色。不用继续往上更新，因为黑黑可以，红黑也可以，就不用管了。
    在这里插入图片描述
    关键看叔叔

判断是不是红黑树

用4个规则进行判断，满足这四个规则就满足最长路径不超过最短路径的两倍。

  1. 规则1枚举了颜色就实现了节点不是黑色就是红色
  2. 规则2直接检查根的颜色是不是黑色就可以了
  3. 规则3不能是连续的红色节点，遇到红色节点就检查孩子不太方便，如果孩子不存在就更不方便了，并且孩子可能有两个。但是检查父亲节点的颜色就方便多了，遇到红色节点就检查父亲节点的颜色。
  4. 规则4是每条路径的黑色节点的数量必须相同。用前序遍历检查，用形参blacknum记录到当前节点的黑色节点的数量，遇到黑色节点就++，走到空就计算完一条路径的黑色节点的数量。用任意一条的黑色节点的数量作为参考值，依次比较。
    在这里插入图片描述
// 判断红黑树是否平衡
bool IsBalance()
{
	// 根节点是空
	if (_root == nullptr)
		return true;
	// 根节点非空且是红色
	if (_root->_col == RED)
		return false;

    // 算出一条路径上黑色节点的个数作为参考值
	Node* cur = _root;
	// 参考值
	int blacknum = 0;
	while (cur)
	{
		if (cur->_col == BLACK)
		{
			++blacknum;
		}
		// 就走最左边的一条路径
		cur = cur->_left;
	}

	return Check(_root,0,blacknum);
}

private:
bool Check(Node* root, int blacknum, const int refnum)
{
	// refnum参考值
	if (root == nullptr)
	{
		// 当前路径走完了
		if (blacknum != refnum)
		{
			cout << "存在黑色节点的数量不相等的路径" << endl;
			return false;
		}
		return true;
	}

	// 规则3
	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << "存在连续两个红节点" << endl;
		return false;
	}

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

	return Check(root->_left, blacknum, refnum) &&
		Check(root->_right, blacknum, refnum);
}

代码

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

// 枚举红黑树的颜色
enum Colour
{
	RED,
	BLACK
};

// 按Key/Value的模式实现
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)
	{}
};

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->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		// 链接父亲节点
		cur->_parent = parent;

		// parent是红色,出现了连续的红色节点,需要向上调整
		// 调整之后cur是根,cur的parent是nullptr
		while (parent&&parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				 //   g
			    // p     u
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					// 变色是为了处理连续的红节点,保证黑节点的数量不变,
					// 向上继续调整是因为grandfather的节点可能是黑节点就结束,
					// 可能是红节点就继续向上处理
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// uncle不存在或uncle存在且为黑
					//   g
				   // p     u
				  // c
				  // 右单旋
					if (cur == parent->_left)
					{
						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
			{
				 //   g
			    // u     p
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续向上更新
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					// uncle不存在或者存在且是黑
					//    g
				    // u     p
				   //          c
				   // 左单旋
					if (parent->_right == cur)
					{
						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;
	}


	// 右单旋,旋转点是parent
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		// b可能为空树
		if (subLR != nullptr)
			subLR->_parent = parent;

		// 记录parent的parent
		Node* pParent = parent->_parent;

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

		// 1. 10是这棵树的总根
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			// 2. 10是这棵树的局部根
			// pParent左可能是parent,右也可能是parent
			if (pParent->_left == parent)
			{
				pParent->_left = subL;
			}
			else
			{
				pParent->_right = subL;
			}
			subL->_parent = pParent;
		}
	}

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

		parent->_right = subRL;
		// b不是空树
		if (subRL)
			subRL->_parent = parent;

		// 记录父亲节点的父亲节点
		Node* pParent = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		// 1. 10是这棵树的总根
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			// 2. 10是这棵树的局部根
			if (pParent->_left == parent)
			{
				pParent->_left = subR;
			}
			else
			{
				pParent->_right = subR;
			}
			subR->_parent = pParent;
		}
	}

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

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

	int Size()
	{
		return _Size(_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 nullptr;
	}

	bool IsBalance()
	{
		// 根节点是空
		if (_root == nullptr)
			return true;
		// 根节点非空且是红色
		if (_root->_col == RED)
			return false;

	    // 算出一条路径上黑色节点的个数作为参考值
		Node* cur = _root;
		// 参考值
		int blacknum = 0;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++blacknum;
			}
			// 就走最左边的一条路径
			cur = cur->_left;
		}

		return Check(_root,0,blacknum);
	}
     
private:
	bool Check(Node* root, int blacknum, const int refnum)
	{
		// refnum参考值
		if (root == nullptr)
		{
			// 当前路径走完了
			if (blacknum != refnum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}
			return true;
		}

		// 规则3
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "存在连续两个红节点" << endl;
			return false;
		}

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

		return Check(root->_left, blacknum, refnum) &&
			Check(root->_right, blacknum, refnum);
	}

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

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

	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 _Size(Node* root)
	{
		if (root == nullptr)
			return 0;

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

private:
	Node* _root = nullptr;
};

#define _CRT_SECURE_NO_WARNINGS

#include"RBTree.h"

void TestRBTree1()
{
	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 };

	for (auto e : a)
	{
		t.Insert({ e,e });
	}

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

int main()
{
	TestRBTree1();

	return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

csapp2.4节——浮点数

csapp2.4节——浮点数

目录 二进制小数 十进制小数转二进制小数 IEEE浮点表示 规格化表示 非规格化表示 特殊值 舍入 浮点运算 二进制小数 类比十进制中的小数&#xff0c;可定义出二进制小数 例如1010.0101 小数点后的权重从-1开始递减。 十进制小数转二进制小数 整数部分使用辗转相除…
阅读更多...
神经网络|(一)加权平均法，感知机和神经元

神经网络|(一)加权平均法，感知机和神经元

【1】引言 从这篇文章开始&#xff0c;将记述对神经网络知识的探索。相关文章都是学习过程中的感悟和理解&#xff0c;如有雷同或者南辕北辙的表述&#xff0c;请大家多多包涵。 【2】加权平均法 在数学课本和数理统计课本中&#xff0c;我们总会遇到求一组数据平均值的做法…
阅读更多...
Spring 框架：配置缓存管理器、注解参数与过期时间

Spring 框架：配置缓存管理器、注解参数与过期时间

在 Spring 框架中&#xff0c;可通过多种方式配置缓存具体行为&#xff0c;常见配置方法如下。 1. 缓存管理器&#xff08;CacheManager&#xff09;配置 基于内存的缓存管理器配置&#xff08;以SimpleCacheManager为例&#xff09; SimpleCacheManager 是 Spring 提供的简单…
阅读更多...
FPGA实现任意角度视频旋转（完结）视频任意角度旋转实现

FPGA实现任意角度视频旋转（完结）视频任意角度旋转实现

本文主要介绍如何基于FPGA实现视频的任意角度旋转&#xff0c;关于视频180度实时旋转、90/270度视频无裁剪旋转&#xff0c;请见本专栏前面的文章&#xff0c;旋转效果示意图如下&#xff1a; 为了实时对比旋转效果&#xff0c;采用分屏显示进行处理&#xff0c;左边代表旋转…
阅读更多...
openlayer getLayerById 根据id获取layer图层

openlayer getLayerById 根据id获取layer图层

背景&#xff1a; 在项目中使用getLayerById获取图层&#xff0c;这个getLayerById()方法不是openlayer官方文档自带的&#xff0c;而是自己封装的一个方法&#xff0c;这个封装的方法的思路是&#xff1a;遍历所有的layer&#xff0c;根据唯一标识【可能是id&#xff0c;也可能…
阅读更多...
设计模式-建造者模式、原型模式

设计模式-建造者模式、原型模式

目录 建造者模式 定义 类图 优缺点 角色 建造者模式和工厂模式比较 使用案例 原型模式 定义 类图 优缺点 应用场景 应用类型 浅克隆 深克隆 建造者模式 定义 将一个复杂的对象的构造与它的表示分离&#xff0c;使同样的构建过程可以创建不同的表示&#xff0c;…
阅读更多...
PTMD2.0-疾病相关的翻译后修饰数据库

PTMD2.0-疾病相关的翻译后修饰数据库

翻译后修饰&#xff08;PTMs&#xff0c;post-translational modifications&#xff09;通过调节蛋白质功能参与了几乎所有的生物学过程&#xff0c;而 PTMs 的异常状态常常与人类疾病相关。在此&#xff0c;PTMD 2.0展示与疾病相关的 PTMs 综合数据库&#xff0c;其中包含 93 …
阅读更多...
【Git版本控制器--3】Git的远程操作

【Git版本控制器--3】Git的远程操作

目录 理解分布式版本控制系统 创建远程仓库 仓库被创建后的配置信息 克隆远程仓库 https克隆仓库 ssh克隆仓库 向远程仓库推送 拉取远程仓库 忽略特殊文件 为什么要忽略特殊文件&#xff1f; 如何配置忽略特殊文件&#xff1f; 配置命令别名 标签管理 理…
阅读更多...
批量创建ES索引

批量创建ES索引

7.x from elasticsearch import Elasticsearch# 配置 Elasticsearch 连接 # 替换为你的 Elasticsearch 地址、端口、用户名和密码 es Elasticsearch([http://10.10.x.x:43885],basic_auth(admin, XN272G9THEAPYD5N5QORX3PB1TSQELLB) )# # 测试连接 # try: # # 尝试获取集…
阅读更多...
MySQL中的读锁与写锁：概念与作用深度剖析

MySQL中的读锁与写锁：概念与作用深度剖析

MySQL中的读锁与写锁&#xff1a;概念与作用深度剖析 在MySQL数据库的并发控制机制中&#xff0c;读锁和写锁起着至关重要的作用。它们是确保数据在多用户环境下能够正确、安全地被访问和修改的关键工具。 一、读锁&#xff08;共享锁&#xff09;概念 读锁&#xff0c;也称为…
阅读更多...
专利申请的价值

专利申请的价值

独占市场 一种产品只要授权专利权&#xff0c;等于在市场上拥有独占权。 政策奖励 各地方政府均出台响应文件&#xff0c; 对专利申请者进行奖励或者补助。 申报项目 申报高新技术企业、创新基金等 各类计划、项目的必要前提条件 专利申请 技术保护 防止新的技术与产品被他人 抄…
阅读更多...
使用 OpenCV 和 Python 轻松实现人脸检测

使用 OpenCV 和 Python 轻松实现人脸检测

目录 一、准备工作 二、加载人脸检测模型 三、读取图像并进行人脸检测 四、处理视频中的人脸检测 五、优化人脸检测效果 六、总结 在人工智能和计算机视觉领域，人脸检测是一项非常基础且重要的技术。通过人脸检测，我们可以在图像或视频中识别并定位人脸，进而进行后续的…
阅读更多...
自然语言处理——从原理、经典模型到应用

自然语言处理——从原理、经典模型到应用

1. 概述 自然语言处理&#xff08;Natural Language Processing&#xff0c;NLP&#xff09;是一门借助计算机技术研究人类语言的科学&#xff0c;是人工智能领域的一个分支&#xff0c;旨在让计算机理解、生成和处理人类语言。其核心任务是将非结构化的自然语言转换为机器可以…
阅读更多...
2025年新开局！谁在引领汽车AI风潮？

2025年新开局！谁在引领汽车AI风潮？

汽车AI革命已来。 在2025年伊始开幕的CES展上&#xff0c;AI汽车、AI座舱无疑成为了今年汽车行业的最大热点。其中不少车企在2025年CES上展示了其新一代AI座舱&#xff0c;为下一代智能汽车的人机交互、场景创新率先打样。 其中&#xff0c;东软集团也携带AI驱动、大数据支撑…
阅读更多...
YOLO目标检测3

YOLO目标检测3

一. 参考资料 《YOLO目标检测》 by 杨建华博士 本篇文章的主要内容来自于这本书&#xff0c;只是作为学习记录进行分享。 二. 搭建YOLOv1的网络 2.1 YOLOv1的网络结构 作者带我们构建的YOLOv1网络是一个全卷积结构&#xff0c;其中不包含任何全连接层&#xff0c;这一点可以…
阅读更多...
css3 svg制作404页面动画效果HTML源码

css3 svg制作404页面动画效果HTML源码

源码介绍 css3 svg制作404页面动画效果HTML源码&#xff0c;源码由HTMLCSSJS组成&#xff0c;记事本打开源码文件可以进行内容文字之类的修改&#xff0c;双击html文件可以本地运行效果 效果预览 源码如下 <!doctype html> <html> <head> <meta charse…
阅读更多...
LINUX 平台最快子网路由转发，内核使能选项配置

LINUX 平台最快子网路由转发，内核使能选项配置

阅读本文之间&#xff0c;可线性参考以下文献。 Linux 命令行配置为单臂旁路由。_linux单臂路由-CSDN博客 Linux 软路由命令行配置&#xff08;参考&#xff09;_linux软路由-CSDN博客 VGW在 Windows 平台上局域网就绪的旁路由器程序_windows旁路由-CSDN博客 本文介绍 LINUX…
阅读更多...
RNN实现阿尔茨海默症的诊断识别

RNN实现阿尔茨海默症的诊断识别

本文为为&#x1f517;365天深度学习训练营内部文章 原作者&#xff1a;K同学啊 一 导入数据 import torch.nn as nn import torch.nn.functional as F import torchvision,torch from sklearn.preprocessing import StandardScaler from torch.utils.data import TensorDatase…
阅读更多...
HackTheBox靶机：Sightless；NodeJS模板注入漏洞，盲XSS跨站脚本攻击漏洞实战

HackTheBox靶机：Sightless；NodeJS模板注入漏洞，盲XSS跨站脚本攻击漏洞实战

HackTheBox靶机&#xff1a;Sightless 渗透过程1. 信息收集常规探测深入分析 2. 漏洞利用&#xff08;CVE-2022-0944&#xff09;3. 从Docker中提权4. 信息收集&#xff08;michael用户&#xff09;5. 漏洞利用 Froxlor6. 解密Keepass文件 漏洞分析SQLPad CVE-2022-0944 靶机介…
阅读更多...
docker安装elk6.7.1-搜集java日志

docker安装elk6.7.1-搜集java日志

docker安装elk6.7.1-搜集java日志 如果对运维课程感兴趣&#xff0c;可以在b站上、A站或csdn上搜索我的账号&#xff1a; 运维实战课程&#xff0c;可以关注我&#xff0c;学习更多免费的运维实战技术视频 0.规划 192.168.171.130 tomcat日志filebeat 192.168.171.131 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023