C++数据结构——红黑树

一，关于红黑树

红黑树也是一种平衡二叉搜索树，但在每个节点上增加一个存储位表示节点的颜色，颜色右两种，红与黑，因此也称为红黑树。

通过对任意一条从根到叶子的路径上各个节点着色方式的限制，红黑树可以确保没有一条路径会比其他路径长出两倍，因此是“近似平衡”。

下面就是一棵红黑树：

结合上面的图，我们可以了解下红黑树成立的各种条件：

①每个节点不是红色就是黑色

②根节点是黑色的

③如果一个节点是红色的，那么这个红色节点的两个孩子节点都是黑色的

④对于每个节点，从该节点到其所有后代叶结点的路径上，黑色节点的数量相同

⑤每个叶子节点都是黑色的（这里所说的叶子节点是上图中的空节点）

二，红黑树节点和结构定义

2.1 节点

//用枚举来标识颜色
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)
	{}
};

2.2 结构

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

    //此处实现各种成员函数和接口

private:
    Node* _root = nullptr;
}

三，红黑树插入*

3.1 基本插入

基本插入也和之前的差不多，直接上代码：

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);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{ 
		parent->_left = cur;
	}
	cur->_parent = parent;
	//插入完成，开始改变颜色和调整旋转
	cur->_col = RED;//把新插入的节点都搞成红色，因为如果插入后改为黑色，一定违反规则四：每条路径的黑色节点数量相同
	//如果父亲是黑色节点或者插入前是空树，直接摊牌不玩了，不进入循环

	while (parent && parent->_col == RED)//父节点存在且父节点为红色
	{
        //这里的循环控制平衡，具体看下面的各种情况
        
    }
}

按搜索树的性质插入之后就是要判断红黑树的性质是否遭到破坏。

新插入节点默认为红色，因此：如果双亲节点颜色是黑色，那么没有违反红黑树的任何性质，不需要调整，就是上面代码最后的循环直接跳过；但是如果新插入的节点的双亲为红色，就违反了上面的规则“红节点的孩子为黑”，也就是出现了连续的红节点，需要调整，就是进入上面的循环部分

此时就要分下面的几条情况来讨论，维持平衡的方法的关键就是看叔叔也就是父亲的兄弟节点的状态

3.2 情况一：uncle节点存在且为红

3.2.1 cur是新增节点

如下图（假设cur是新增）：

uncle存在且为红时，我们直接将父节点和叔叔节点都变成黑，再将爷爷节点变为红，但是只这样做肯定不行，比如下图：

一次调整过后就会出现上面的情况，所以需要不断往上调整

3.2.2 cur不是新增节点

如下图：

如上图，cur本身是黑色，是树中原来的节点，因为子树有新增变成了红，所以对于cur节点有两种情况符合情况一：

①本身是新增，默认新增节点为红

②子树有新增，通过情况一的向上调整变成了红 

3.3 情况二+情况三：uncle不存在或者存在为黑

从情况一我们可以看出，cur可能是新节点也可能不是新节点，但最终结果都是变红。

如果uncle节点不存在，那么cur一定是新增，如果cur不是新增，最开始循环的条件为父节点存在且为红，又因为红节点的孩子为黑这条性质，cur必定为黑，但是由于uncle不存在，导致以爷爷节点为根的子树左右子树黑节点数量不一样。

所以如果uncle不存在，cur必定为新增，如下图：

而对于uncle节点存在且为黑时， 那么cur原来肯定是黑色的因为父节点是红的，右因为左右两边黑色节点数量要一致，cur的孩子也为红，这时候在cur孩子后面新增节点时，就变成了情况一，会不断向上调整颜色，也会把cur变成红色，如下图：

所以，情况二和情况三的最终情况都是cur为红，所以可以放在一起讨论

3.4 插入代码

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);
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;
	//插入完成，开始改变颜色和调整旋转
	cur->_col = RED;//把新插入的节点都搞成红色，因为如果插入后改为黑色，一定违反规则四：每条路径的黑色节点数量相同
	//如果父亲是黑色节点或者插入前是空树，直接摊牌不玩了，不进入循环

	while (parent && parent->_col == RED)//父节点存在且父节点为红色
	{
		//找祖父
		Node* grandfather = parent->_parent;
		assert(grandfather);
		assert(grandfather->_col == BLACK);
		//红黑树的关键看叔叔，也就是父亲的兄弟
		if (parent == grandfather->_left)//父亲在爷爷的左边，叔叔分为几种情况分开讨论
		{
			Node* uncle = grandfather->_right;//父亲在左边，那么叔叔就在右边
			//情况一:uncle存在且为红
			if (uncle && uncle->_col == RED)
			{
				//父亲和叔叔变黑是为了替代祖父的黑，祖父变红是为了保持黑色节点数量不变
				parent->_col = uncle->_col = BLACK;//把父亲和叔叔变黑
				grandfather->_col = RED;//把祖父变红
				//继续往上处理 -- 将祖父当成新增节点，循环往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			//情况二+三,uncle不存在 + 存在且为黑
			else
			{
				//新增在左边:右单旋+变色
				//      g            p
				//   p     u  --> c     g 
				//c                         u
				if (cur == parent->_left)
				{
					RotateR(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				//新增在右边:左单旋 + 右双旋+变色
				//     g
				//  p     u   -->   
				//    c
				else
				{
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else//父亲在右边，叔叔可能在左边  (parent == grandfather->_right)
		{
			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 (cur == parent->_right)
				{
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				//新增在左边:左右双旋+变色
				//     g
				//  u     p
				//       c
				else
				{
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}

				break;
			}

		}
	}
	//循环结束
	_root->_col = BLACK;
	return true;
}

四，其他接口实现

4.1 左旋转函数

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

	parent->_right = subRL;
	//subRL可能是空
	if (subRL)
	{
		subRL->_parent = parent;
	}
	//记录一下要旋转的parent节点的_parent，用于当parent是子树根时的调整
	Node* ppNode = parent->_parent;

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

	//parent是整棵树的根
	if (_root == parent)
	{
		_root = subR;
		subR->_parent = nullptr;
	}
	else//parent是子树的根
	{
		if (ppNode->_left == parent)
		{
			ppNode->_left = subR;
		}
		else
		{
			ppNode->_right = subR;
		}
		subR->_parent = ppNode;
	}
}

4.2 右旋转函数

//右旋转函数
void RotateR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;

	parent->_left = subLR;
	//subLR可能是空
	if (subLR)
	{
		subLR->_parent = parent;
	}
	//记录一下要旋转的parent节点的_parent，用于当parent是子树根时的调整
	Node* ppNode = parent->_parent;

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

	//parent是整颗树的根
	if (_root == parent)
	{
		_root = subL;
		subL->_parent = nullptr;
	}
	else
	{
		if (ppNode->_left == parent)
		{
			ppNode->_left = subL;
		}
		else
		{
			ppNode->_right = subL;
		}
		subL->_parent = ppNode;
	}
}

4.3 检查函数

public:
	bool IsBalance() //根据规则来检查
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点不是黑色" << endl;
			return false;
		}

		//定义基准值，用来判断每条路径的黑色节点数量是否相同
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++benchmark;
			}
			cur = cur->_left;
		}

		//检查连续红色节点
		return _Check(_root,0,benchmark);

	}
private:
	bool _Check(Node* root,int blackNum,int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点数量不相等";
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续红节点" << endl;
			return false;
		}
		return _Check(root->_left,blackNum,benchmark) && _Check(root->_right,blackNum,benchmark);
	}

 4.4 打印

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}
private:
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}

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

4.5 查找

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

4.6 析构

~RBTree()
{
	_Destroy(_root);
	_root == nullptr;
}
private:
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
		root == nullptr;
	}

五，红黑树源代码和测试代码

源代码(RBTree.h)

#pragma once
//最长路径不超过最短路径的两倍

//红黑树和AVL树相比来说，红黑树的优点是旋转的次数更少
//如果两个树都插入1万个树，查找时，AVL树最多要查找30次，红黑树最多查找60次
// 但是这种差别对于CPU来说可以忽略不计，所以论综合性能，还是红黑树更胜一筹
#include<iostream>
#include<assert.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:
	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;
			}
		}
	}
	~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
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{ 
			parent->_left = cur;
		}
		cur->_parent = parent;
		//插入完成，开始改变颜色和调整旋转
		cur->_col = RED;//把新插入的节点都搞成红色，因为如果插入后改为黑色，一定违反规则四：每条路径的黑色节点数量相同
		//如果父亲是黑色节点或者插入前是空树，直接摊牌不玩了，不进入循环

		while (parent && parent->_col == RED)//父节点存在且父节点为红色
		{
			//找祖父
			Node* grandfather = parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//红黑树的关键看叔叔，也就是父亲的兄弟
			if (parent == grandfather->_left)//父亲在爷爷的左边，叔叔分为几种情况分开讨论
			{
				Node* uncle = grandfather->_right;//父亲在左边，那么叔叔就在右边
				//情况一:uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					//父亲和叔叔变黑是为了替代祖父的黑，祖父变红是为了保持黑色节点数量不变
					parent->_col = uncle->_col = BLACK;//把父亲和叔叔变黑
					grandfather->_col = RED;//把祖父变红
					//继续往上处理 -- 将祖父当成新增节点，循环往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				//情况二+三,uncle不存在 + 存在且为黑
				else
				{
					//新增在左边:右单旋+变色
					//      g            p
					//   p     u  --> c     g 
					//c                         u
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//新增在右边:左单旋 + 右双旋+变色
					//     g
					//  p     u   -->   
					//    c
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//父亲在右边，叔叔可能在左边  (parent == grandfather->_right)
			{
				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 (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					//新增在左边:左右双旋+变色
					//     g
					//  u     p
					//       c
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}

			}
		}
		//循环结束
		_root->_col = BLACK;
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
	bool IsBalance() //根据规则来检查
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点不是黑色" << endl;
			return false;
		}

		//定义基准值，用来判断每条路径的黑色节点数量是否相同
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++benchmark;
			}
			cur = cur->_left;
		}

		//检查连续红色节点
		return _Check(_root,0,benchmark);

	}
private:
	bool _Check(Node* root,int blackNum,int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark != blackNum)
			{
				cout << "某条路径黑色节点数量不相等";
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "存在连续红节点" << endl;
			return false;
		}
		return _Check(root->_left,blackNum,benchmark) && _Check(root->_right,blackNum,benchmark);
	}
	//左旋转函数
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		//subRL可能是空
		if (subRL)
		{
			subRL->_parent = parent;
		}
		//记录一下要旋转的parent节点的_parent，用于当parent是子树根时的调整
		Node* ppNode = parent->_parent;

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

		//parent是整棵树的根
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else//parent是子树的根
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}
	//右旋转函数
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//subLR可能是空
		if (subLR)
		{
			subLR->_parent = parent;
		}
		//记录一下要旋转的parent节点的_parent，用于当parent是子树根时的调整
		Node* ppNode = parent->_parent;

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

		//parent是整颗树的根
		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}
	//打印子函数
	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;
		root == nullptr;
	}
private:
	Node* _root = nullptr;
};

测试

#include"RBTree.h"

void TestRBTree1()
{
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert(make_pair(e, e));
	}
	cout << "IsBalance:" << t1.IsBalance() << endl;
}

void TestRBTree2()
{
	size_t N = 10000;
	srand(time(0));
	RBTree<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		int x = rand();
		cout << "Insert:" << x << ":" << i << endl;
		t1.Insert(make_pair(x, i));
	}
	cout << "IsBalance:" << t1.IsBalance() << endl;
}


int main()
{
	TestRBTree2();
	cout << endl;
	TestRBTree1();
	return 0;
}

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

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

相关文章

ChatGLM论文解读

ChatGLM论文解读

GLM GLM: General Language Model Pretraining with Autoregressive Blank Infilling 论文地址 1. 背景介绍 1）主流预训练框架 模型介绍结构特点训练目标autoregressive自回归模型，代表GPT，本质上是一个从左到右的语言模型，常用于无条件生成任务（unconditional generat…
阅读更多...
[BJDCTF2020]ZJCTF，不过如此（特详解）

[BJDCTF2020]ZJCTF，不过如此（特详解）

php特性 1.先看代码&#xff0c;提示了next.php&#xff0c;绕过题目的要求去回显next.php 2.可以看到要求存在text内容而且text内容强等于后面的字符串&#xff0c;而且先通过这个if才能执行下面的file参数。 3.看到用的是file_get_contents()函数打开text。想到用data://协…
阅读更多...
Airflow【部署 01】Airflow官网Quick Start实操（一篇学会部署Airflow）

Airflow【部署 01】Airflow官网Quick Start实操（一篇学会部署Airflow）

Airflow官网Quick Start实操 1.环境变量设置2.使用约束文件进行安装3.启动单机版3.1 快速启动3.2 分步骤启动3.3 启动后3.4 服务启动停止脚本 4.访问4.1 登录4.2 测试 来自官网的介绍&#xff1a; https://airflow.apache.org/ Airflow™是一个由社区创建的平台&#xff0c;以…
阅读更多...
【Unity学习笔记】第十一 · 动画基础（Animation、状态机、root motion、bake into pose、blendTree、大量案例）

【Unity学习笔记】第十一 · 动画基础（Animation、状态机、root motion、bake into pose、blendTree、大量案例）

转载引用请注明出处&#xff1a;&#x1f517;https://blog.csdn.net/weixin_44013533/article/details/132081959 作者&#xff1a;CSDN|Ringleader| 如果本文对你有帮助&#xff0c;不妨点赞收藏关注一下&#xff0c;你的鼓励是我前进最大的动力&#xff01;ヾ(≧▽≦*)o 主…
阅读更多...
SSL证书 DV、OV、EV等级的证书适用群体

SSL证书 DV、OV、EV等级的证书适用群体

DV&#xff08;Domain Validation&#xff0c;域名验证&#xff09;证书 特点&#xff1a;DV证书是最基础的SSL/TLS证书类型&#xff0c;仅验证申请证书的实体是否对该域名有控制权。验证过程相对简单快速&#xff0c;通常只需要验证域名的所有权即可。 适用人群&#xff1a;…
阅读更多...
教学方法有哪些种类

教学方法有哪些种类

作为一位老师&#xff0c;面对不同的学生和课程&#xff0c;掌握多种教学方法是必不可少的。你知道吗&#xff1f;教学方法不仅关乎教学效果&#xff0c;还直接影响学生的学习热情和兴趣。这篇文章将为你揭秘教学方法的神秘面纱&#xff0c;看看有哪些种类的教学方法&#xff0…
阅读更多...
初识计算机网络 | 计算机网络的发展 | 协议初识

初识计算机网络 | 计算机网络的发展 | 协议初识

1.计算机网络的发展 “矛盾是普遍存在的&#xff0c;矛盾是事物联系的实质内容和事物发展的根本动力&#xff01;” 计算机在诞生之初&#xff0c;在军事上用来计算导弹的弹道轨迹&#xff01;在发展的过程中&#xff08;商业的推动&#xff0c;国家政策推动&#xff09;&…
阅读更多...
Nginx 配置解析：从基础到高级应用指南

Nginx 配置解析：从基础到高级应用指南

Nginx 配置解析&#xff1a;从基础到高级应用指南 Nginx 配置解析&#xff1a;从基础到高级应用指南1. 安装和基本配置安装 Nginx基本配置 2. 虚拟主机配置3. 反向代理配置4. 负载均衡配置5. SSL 配置6. 高级配置选项结语 Nginx 配置解析&#xff1a;从基础到高级应用指南 Ngi…
阅读更多...
rank是MySQL关键字

rank是MySQL关键字

MySQL有rank关键字&#xff0c;建议将rank替换为rank 。不是单引号 是键盘1左边的符号。 rank()&#xff1a;返回的相关等级会跳跃&#xff1b; dense_rank()&#xff1a;返回的相关等级不会跳跃&#xff1b; row_number()&#xff1a;返回的是行信息&#xff0c;没有排名&a…
阅读更多...
elementui的el-table自定义控制展开事件，实现“展开”“收起”的切换（两种效果）【超级完整式代码】

elementui的el-table自定义控制展开事件，实现“展开”“收起”的切换（两种效果）【超级完整式代码】

第一种&#xff1a;多行点击展开其他行不收起 先看效果图 直接上代码 【核心代码添加标注简单易懂】 <el-tableref"multipleTable":data"smsLogList.slice((currentPage - 1) * pageSize_, currentPage * pageSize_)"tooltip-effect"dark"st…
阅读更多...
程序员必备的20个学习网站

程序员必备的20个学习网站

今天好学编程小编整理了20个程序员必备的学习网站&#xff0c;此篇对于新手程序员比较有用&#xff0c;技术老鸟们也可以查缺补漏。话不多说&#xff0c;纯纯干货呈上&#xff0c;赶紧点个赞收藏&#xff0c;以后会用得上&#xff01; 技术网站类 1、博客园 一个面向开发者的…
阅读更多...
6.jmeter非GUI命令及Beanshell组件

6.jmeter非GUI命令及Beanshell组件

一、非GUI&#xff08;界面&#xff09;命令详解 1. -n 使用非gui方式&#xff0c;不能单独使用&#xff0c;必须和-t&#xff08;指定jmeter的脚本&#xff09;一起用。 #cmd命令行模式下&#xff0c;进入存放测试jmx文件的目录下 jmeter -n -t hello.jmx只会生成一个log日…
阅读更多...
docker 安装redis

docker 安装redis

1. docker pull redis指定版本安装&#xff1a; docker pull redis:5.0 # 5.0 是指定版本号2运行redis docker run --name my-redis -p 6379:6379 -d redis 3查看 docker ps 6停止启动redis docker stop my-redis docker start my-redis 补充知识点 docker ps -a…
阅读更多...
五分钟学会接口自动化测试框架

五分钟学会接口自动化测试框架

今天&#xff0c;我们来聊聊接口自动化测试。 接口自动化测试是什么&#xff1f;如何开始&#xff1f;接口自动化测试框架如何搭建&#xff1f; 自动化测试 自动化测试&#xff0c;这几年行业内的热词&#xff0c;也是测试人员进阶的必备技能&#xff0c;更是软件测试未来发…
阅读更多...
线上版本升级 — — pg数据库备份

线上版本升级 — — pg数据库备份

线上版本升级 — — pg数据库备份 在版本升级之前&#xff0c;我们通常为了保险都需要将数据库里的数据结构备份一份&#xff0c;防止升级失败之后数据丢失。&#xff08;根据业务而来&#xff0c;并非所有业务都需要备份&#xff09; 1 备份 1.1 pg_dump&#xff1a;备份指定…
阅读更多...
【Flink-1.17-教程】-【四】Flink DataStream API（1）源算子（Source）

【Flink-1.17-教程】-【四】Flink DataStream API（1）源算子（Source）

【Flink-1.17-教程】-【四】Flink DataStream API&#xff08;1&#xff09;源算子&#xff08;Source&#xff09; 1&#xff09;执行环境&#xff08;Execution Environment&#xff09;1.1.创建执行环境1.2.执行模式&#xff08;Execution Mode&#xff09;1.3.触发程序执行…
阅读更多...
Hudi学习笔记(一)

Hudi学习笔记(一)

大数据发展背景 Hudi用于管理分布式文件系统上大型分析数据集存储&#xff0c;支持Spark和Flink整合。它能够是DFS数据集在分钟级时延内支持变更&#xff0c;也支持下游系统对这个数据集的增量处理。 学习目标 什么是数据湖为什么使用数据湖Hudi基本功能如何编译Hudi源码Hud…
阅读更多...
抖音账号矩阵系统开发

抖音账号矩阵系统开发

技术自研框架开发背景&#xff1a; 抖音账号矩阵系统是一种基于数据分析和管理的全新平台&#xff0c;能够帮助用户更好地管理、扩展和营销抖音账号。 部分源码分享&#xff1a;计算分页$active_list_all $Video_model->getCount($where);$page_libs newLibs_Pagination_…
阅读更多...
PyQtGraph 之PlotCurveItem 详解

PyQtGraph 之PlotCurveItem 详解

PyQtGraph 之PlotCurveItem 详解 PlotCurveItem 是 PyQtGraph 中用于显示曲线的图形项。以下是 PlotCurveItem 的主要参数和属性&#xff1a; 创建 PlotCurveItem 对象 import pyqtgraph as pg# 创建一个 PlotCurveItem curve pg.PlotCurveItem()常用的参数和属性 setData(…
阅读更多...
02 分解质因子

02 分解质因子

一、数n的质因子分解 题目描述&#xff1a; 输入一个数n&#xff08;n<10^6&#xff09;,将数n分解质因数&#xff0c;并按照质因数从小到大的顺序输出每个质因数的底数和指数。 输入 5 输出 5 1 输入 10 输出 2 1 5 1 朴素解法&#xff1a; 首先求出1~n的所有质数…
阅读更多...
最新文章

Copyright @ 2022~2023