二叉搜索树-----红黑树

news2024/9/24 23:28:25

✅<1>主页：我的代码爱吃辣
📃<2>知识讲解：数据结构——红黑树
☂️<3>开发环境：Visual Studio 2022
💬<4>前言：红黑树也是一颗二叉搜索树，其作为map，set的底层容器，具有非常好的搜索性能，仅仅通过控制颜色和位置就能达到一种，近似平衡的效果，大大减少了旋转的次数。

目录

一.红黑树的概念

二. 红黑树的性质

三.红黑树节点及其整体的定义

四.红黑树的插入操作

五.红黑树 find

六.析构函数

七.红黑树的验证

八. 红黑树与AVL树的比较

一.红黑树的概念

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

二. 红黑树的性质

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

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

答案：因为性质3限制了，一条路径上，不可能出现连续的两个红色结点。又因为性质4，每条路径上黑色结点数目相同，那么最短路径就一定是全是黑色结点的路径，最长路径一定是红黑交错的路径，因为根节点一定是黑色，那么最长路径上红黑结点树一定是相等的，所以最长路径最多是最短路径的两倍。

三.红黑树节点及其整体的定义

//枚举
enum Color
{
	RED,//红色
	BLACK//黑色
};
template<class K,class V>
struct _RBTreeNode
{
	_RBTreeNode(pair<K,V> kv)
		:_kv(kv),
		_col(RED),//默认红色
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr)
	{
	}

	pair<K, V> _kv;              //存储数值
	Color _col;                  //颜色
	_RBTreeNode<K, V>* _left;    //左孩子
	_RBTreeNode<K, V>* _right;   //右孩子
	_RBTreeNode<K, V>* _parent;  //父亲
};
#pragma once
#include<iostream>
using namespace std;


template<class K,class V>
class RBTRee
{
	typedef _RBTreeNode<K, V> Node;//结点
public:
	Node* find(const K key)
	{
		//....
	}
	bool insert(pair<K, V> kv)
	{
		//....
	}
	void Inorder()
	{
		//...
	}

	~RBTRee()
	{
		//...
	}

private:
	Node* _root = nullptr;//根节点
};

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？

答案：新创建的结点，妖色要么红色，要么黑色，除了颜色区别之外，就是在插入时对整个树的影响不同，如果插入的是黑色，会影响整颗树，所有路径上的黑色结点说就会不同，必然违反性质4。如果插入的是红色结点，仅仅是局部的影响，可能会影响性质3，一定不会影响性质4。

 四.红黑树的插入操作

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

1. 按照二叉搜索的树规则插入新节点。

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

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
        //找到了合适的位置
		cur = new Node(kv);
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
        

        //....  
}

因为性质2，所以我们每一次插入数据都想根节点变成黑色。

2.检测新节点插入后，红黑树的性质是否造到破坏，若满足直接退出，否则对红黑树进行旋转着色处理。

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何
性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连
在一起的红色节点，此时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点。

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


解决方式：将 p , u 改为黑，g 改为红，然后把 g 当成 cur，继续向上调整。

情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

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

情况三：cur为红，p为红，g为黑，u不存在/u存在且为黑

  • p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；

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

这里的cur的也有可能是新增的结点，如果是cur本身就是新增节点那么u结点就是不存在的，否则违反规则 4，也有可能是因为cur下面的结点变黑导致 cur 变红色。

代码：

    while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		//           g(B)                     g(R)
		//     p(R)       u(R)  -->     p(B)       u(B)
		//c(R)                     c(R)
		if (grandfather->_left == parent)
		{
			Node* uncle = grandfather->_right;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;

				//继续向上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else //u不存在/u存在且为黑，旋转+变色
			{
				//           g(B)                   p(R)
				//     p(R)       u(B)   -->  u(B)        g(B)
				//c(R)										     u(B)
				if (cur == parent->_left)
				{
					//右单旋
					RotateR(grandfather);
					parent->_col = BLACK;
					//cur->_col = RED;
					grandfather->_col = RED;
				}
				else
				{
					//            g(B)                   P(B)   
					//     p(R)         u(B)  --> c(R)          g(R)
					//         c(R)                                     u(B)
					// 左右双旋
					RotateL(parent);
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else //grandfather->_right == parent,与上述情况相反
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;

				cur = grandfather;
				parent = cur->_parent;
			}
			else //u不存在/u存在且为黑，旋转+变色
			{
				if (cur == parent->_right)
				{
					//左单旋
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					// 右左双旋
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
	}

 旋转：

    void RotateL(Node* parent)
	{
		Node* curR = parent->_right;
		Node* curRL = curR->_left;

		//调整结点，并且修改其父亲结点指针
		parent->_right = curRL;
		if (curRL)//可能为空
		{
			curRL->_parent = parent;
		}
		//在修改子树根节点之前，保存子树根节点的父亲
		Node* pparent = parent->_parent;
		//修改子树根节点
		curR->_left = parent;
		parent->_parent = curR;

		//子树根节点有可能是整棵树的根节点
		if (pparent == nullptr)
		{
			_root = curR;
			_root->_parent = nullptr;
		}
		else//子树根节点不是整棵树的根节点
		{
			//还要看子树是它父亲的左孩子还是右孩子
			if (pparent->_left == parent)
			{
				pparent->_left = curR;
			}
			else
			{
				pparent->_right = curR;
			}
			curR->_parent = pparent;
		}
	}

	void RotateR(Node* parent)
	{
		Node* curL = parent->_left;
		Node* curLR = curL->_right;

		parent->_left = curLR;
		if (curLR)
		{
			curLR->_parent = parent;
		}

		Node* pparent = parent->_parent;

		curL->_right = parent;
		parent->_parent = curL;

		if (parent == _root)
		{
			_root = curL;
			_root->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				pparent->_left = curL;
			}
			else
			{
				pparent->_right = curL;

			}
			curL->_parent = pparent;
		}
	}

红黑树顺序插入：

 红黑树随机插入：

五.红黑树 find

根据二叉搜索树特性去查找：

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

六.析构函数

后续遍历析构树：

    ~RBTRee()
	{
		_Destrory(_root);
		_root = nullptr;
	}

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

		_Destrory(root->_left);
		_Destrory(root->_right);
		delete root;
	}

七.红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质

 其中是否满足搜索树我们只要对其中序遍历是否有序即可。

 完整代码：

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

enum Color
{
	RED,
	BLACK
};
template<class K,class V>
struct _RBTreeNode
{
	_RBTreeNode(pair<K,V> kv)
		:_kv(kv),
		_col(RED),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr)
	{
	}

	pair<K, V> _kv;
	Color _col;
	_RBTreeNode<K, V>* _left;
	_RBTreeNode<K, V>* _right;
	_RBTreeNode<K, V>* _parent;
};

template<class K,class V>
class RBTRee
{
	typedef _RBTreeNode<K, V> Node;
public:
	Node* find(const K key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_kv.first)
			{
				cur = cur->_left;
			}
			else if (key > cur->_kv.first)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
	bool insert(pair<K, V> kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		//找到了合适的位置

		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		while ( parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			//           g(B)                     g(R)
			//     p(R)       u(R)  -->     p(B)       u(B)
			//c(R)                     c(R)
			if ( grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续向上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else //u不存在/u存在且为黑，旋转+变色
				{
					//           g(B)                   p(R)
					//     p(R)       u(B)   -->  u(B)        g(B)
					//c(R)										     u(B)
					if (cur == parent->_left)
					{
						//右单旋
						RotateR(grandfather);
						parent->_col = BLACK;
						//cur->_col = RED;
						grandfather->_col = RED;
					}
					else
					{
						//            g(B)                   P(B)   
						//     p(R)         u(B)  --> c(R)          g(R)
						//         c(R)                                     u(B)
						// 左右双旋
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else //grandfather->_right == parent,与上述情况相反
			{
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else //u不存在/u存在且为黑，旋转+变色
				{
					if (cur == parent->_right)
					{
						//左单旋
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						// 右左双旋
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	void Inorder(vector<K> & v)
	{
		_inorder(_root,v);
		cout << endl;
	}

	~RBTRee()
	{
		_Destrory(_root);
		_root = nullptr;
	}

private:

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

		_Destrory(root->_left);
		_Destrory(root->_right);
		delete root;
	}
    void _inorder(Node* root, vector<K>& v)
	{
		if (root == nullptr)
		{
			return;
		}
		_inorder(root->_left,v);
		v.push_back(root->_kv.first);
		_inorder(root->_right,v);
	}
	void RotateL(Node* parent)
	{
		Node* curR = parent->_right;
		Node* curRL = curR->_left;

		//调整结点，并且修改其父亲结点指针
		parent->_right = curRL;
		if (curRL)//可能为空
		{
			curRL->_parent = parent;
		}
		//在修改子树根节点之前，保存子树根节点的父亲
		Node* pparent = parent->_parent;
		//修改子树根节点
		curR->_left = parent;
		parent->_parent = curR;

		//子树根节点有可能是整棵树的根节点
		if (pparent == nullptr)
		{
			_root = curR;
			_root->_parent = nullptr;
		}
		else//子树根节点不是整棵树的根节点
		{
			//还要看子树是它父亲的左孩子还是右孩子
			if (pparent->_left == parent)
			{
				pparent->_left = curR;
			}
			else
			{
				pparent->_right = curR;
			}
			curR->_parent = pparent;
		}
	}

	void RotateR(Node* parent)
	{
		Node* curL = parent->_left;
		Node* curLR = curL->_right;

		parent->_left = curLR;
		if (curLR)
		{
			curLR->_parent = parent;
		}

		Node* pparent = parent->_parent;

		curL->_right = parent;
		parent->_parent = curL;

		if (parent == _root)
		{
			_root = curL;
			_root->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				pparent->_left = curL;
			}
			else
			{
				pparent->_right = curL;

			}
			curL->_parent = pparent;
		}
	}

	Node* _root = nullptr;

};
	//传参时benchmark是-1，代表还没有基准值，当走完第一条路径时，
	//将第一条路径的黑色节点数作为基准值，后续路径走到null时，就与基准值比较。
	//blacknum记录路径上的黑色节点数
	bool _isRBTree(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark == -1)
			{
				benchmark = blacknum;
			}
			else
			{
				if (blacknum != benchmark)
				{
					cout << "black Node !=" << endl;
					return false;
				}
			}
			return true;
		}

		if (root->_col == BLACK)
		{
			blacknum++;
		}
        //判断时候出现两个连续的红色结点
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "red connect " << endl;
			return false;
		}

		return _isRBTree(root->_left, blacknum, benchmark) && _isRBTree(root->_right, blacknum, benchmark);
	}

main.cpp

#include<vector>
#include<cassert>
#include"RB_Tree.hpp"

int main()
{

	RBTRee<int, int> rb;
	int i = 100000;
	while(i--)
	{
		int num = rand() + i;
		rb.insert(make_pair(num,num));
	}
	vector<int> v;
	rb.Inorder(v);
	for (int i = 0; i < v.size() - 1; i++)
	{
		if (v[i] > v[i + 1])
		{
			assert(0);
		}
	}

	cout << rb.isRBTree() << endl;
	return 0;
}

 八. 红黑树与AVL树的比较

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

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

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

相关文章

AttributeError: module ‘torchvision.io.image‘ has no attribute ‘ImageReadMode‘

AttributeError: module ‘torchvision.io.image‘ has no attribute ‘ImageReadMode‘

我的torch和torchvision版本 import torch torch.__version__‘1.7.1cu110’ import torchvision torchvision.__version__‘0.8.2cu110’ 原代码 mode torchvision.io.image.ImageReadMode.RGB labels.append(torchvision.io.read_image(os.path.join(voc_dir, Segmentat…
阅读更多...
文生图模型之Stable Diffusion

文生图模型之Stable Diffusion

原始文章地址 autoencoder CLIP text encoder tokenizer最大长度为77&#xff08;CLIP训练时所采用的设置&#xff09;&#xff0c;当输入text的tokens数量超过77后&#xff0c;将进行截断&#xff0c;如果不足则进行paddings&#xff0c;这样将保证无论输入任何长度的文本&…
阅读更多...
Vue2向Vue3过度核心技术综合案例

Vue2向Vue3过度核心技术综合案例

目录 1 面经基础版-案例效果分析1.面经效果演示2.功能分析3.实现思路分析&#xff1a;配置路由功能实现 2 面经基础版-一级路由配置3 面经基础版-二级路由配置1.使用场景2.语法3.代码实现 4 面经基础版-二级导航高亮1.实现思路2.代码实现 5 面经基础版-首页请求渲染1.步骤分析2…
阅读更多...
新开通的抖店体验分太低，达人不愿意合作怎么办？解决办法如下

新开通的抖店体验分太低，达人不愿意合作怎么办？解决办法如下

我是王路飞。 找达人带货的玩法是最适合新手抖店商家的&#xff0c;同时也是最适合长线去玩的方法。 但是新手前期找达人的时候&#xff0c;会有一个难点&#xff0c;就是自己的抖店因为是新开通的&#xff0c;所以要么没体验分&#xff0c;要么就是体验分太低了&#xff0c;…
阅读更多...
崔东树：汽车行业正在迎来令人兴奋的时代，智能座舱推动私车普及

崔东树：汽车行业正在迎来令人兴奋的时代，智能座舱推动私车普及

随着新能源汽车和智能座舱的不断发展&#xff0c;汽车行业正经历着一场革命性的变革。当前&#xff0c;不仅汽车电动化的进程在加速推进&#xff0c;智能座舱的升级与完善也成为了行业的热点话题。崔东树指出&#xff0c;随着汽车电动化和智能化的发展&#xff0c;智能座舱的快…
阅读更多...
学习高等数学需要的初等数学知识

学习高等数学需要的初等数学知识

文章目录 名词解释常用希腊字符读音幂、根式和对数常用的三角函数值三角函数变换一元二次方程求解充分条件和必要条件切线方程、斜率和法线隐函数极坐标排列组合 名词解释 教材中存在着许多熟悉且陌生的词汇&#xff0c;作者在此进行了整理&#xff1a; 概念&#xff1a;概念…
阅读更多...
开始MySQL之路—— DDL语法、DML语法、DQL语法基本操作详解

开始MySQL之路—— DDL语法、DML语法、DQL语法基本操作详解

DDL语法 DDL&#xff08;Data Definition Language&#xff09; 数据定义语言&#xff0c;该语言部分包括以下内容。 对数据库的常用操作 对表结构的常用操作 修改表结构 对数据库的常用操作 1: 查看当前所有的数据库 show databases; 2&#xff1a;创建数据库 create dat…
阅读更多...
Linux下的Shell基础——流程控制（三）

Linux下的Shell基础——流程控制（三）

前言&#xff1a; 每门编程都有它独特的语法&#xff0c;比如C语言&#xff0c;Java等编程语言&#xff0c;有相同的地方也有自己独特的地方&#xff0c;但都离不开变量、运算符&#xff0c;条件判断、循环和函数这几个地方的学习&#xff0c;下面就让我们学习一下shell编程里…
阅读更多...
CRM软件的功能与报价如何制定？

CRM软件的功能与报价如何制定？

CRM软件很贵吗&#xff1f;CRM价格与系统功能、部署方式、用户数量、附加服务等有关。当然&#xff0c;不同的CRM厂商&#xff0c;也会有不同的定价模式。下面我们就来说说决定CRM系统报价的几个因素。 系统功能&#xff1a; CRM软件的功能越全面、越强大&#xff0c;其定价也…
阅读更多...
携手共进：OpenAI与ScaleAI开展合作，为企业增强GPT模型微调功能

携手共进：OpenAI与ScaleAI开展合作，为企业增强GPT模型微调功能

8 月 26 日消息&#xff0c;OpenAI 近日发布新闻&#xff0c;除了与Scale AI 展开深度合作外&#xff0c;OpenAI 还宣布他们计划扩展GPT系列的大语言模型。通过与Scale AI 的合作&#xff0c;OpenAI 能够在企业环境中定制GPT-3.5 Turbo和即将发布的GPT-4&#xff0c;以满足不同…
阅读更多...
Typora上使用Mermaid语法展示流程图、时序图、甘特图

Typora上使用Mermaid语法展示流程图、时序图、甘特图

你已经安装Typora并打开了一个新文档后，可以按照以下详细步骤在Typora上使用Mermaid语法展示流程图、时序图、甘特图 流程图 使用graph LR声明开始，并使用箭头和连接符号定义节点之间的关系。例如，A --> B表示从节点A指向节点B的箭头连接。graph TB A[界面布局图] -->…
阅读更多...
npm 卸载 vuecli后还是存在

npm 卸载 vuecli后还是存在

运行了npm uninstall vue-cli -g&#xff0c;之后是up to date in&#xff0c;然后vue -V&#xff0c;版本号一直都在&#xff0c;说明没有卸载掉 1、执行全局卸载命令 npm uninstall vue-cli -g 2、删除vue原始文件 查看文件位置&#xff0c;找到文件删掉 where vue 3、再…
阅读更多...
魏副业而战：闲鱼卖货做什么类目好？

魏副业而战：闲鱼卖货做什么类目好？

我是魏哥&#xff0c;与其躺平&#xff0c;不如魏副业而战&#xff01; 做闲鱼&#xff0c;有人做高客单价的&#xff0c;也有人做低客单价的。 之前魏哥有做宠物产品&#xff0c;利润低&#xff0c;每单赚几元&#xff0c;做的很累&#xff0c;但做过一段时间后发现有很多复…
阅读更多...
左耳朵耗子:TCP 的那些事儿（上）

左耳朵耗子:TCP 的那些事儿（上）

原文地址&#xff1a;https://coolshell.cn/articles/11564.html TCP是一个巨复杂的协议&#xff0c;因为他要解决很多问题&#xff0c;而这些问题又带出了很多子问题和阴暗面。所以学习TCP本身是个比较痛苦的过程&#xff0c;但对于学习的过程却能让人有很多收获。关于TCP这个…
阅读更多...
nrm管理源仓库及发布私人npm包

nrm管理源仓库及发布私人npm包

使用nrm管理源及切换源仓库 1.安装nrm源管理器 npm install nrm -g2.查看目前现有的源仓库 通过 nrm ls 查看现有的源 nrm ls 输出&#xff1a;这是目前现有的源 3.切换不同的源 可以通过 nrm use xxx&#xff08;源仓库名&#xff09;来切换不同的源地址 nrm use taobao…
阅读更多...
激活函数总结（二十）：激活函数补充(SQNL、PLU)

激活函数总结（二十）：激活函数补充(SQNL、PLU)

激活函数总结&#xff08;二十&#xff09;&#xff1a;激活函数补充 1 引言2 激活函数2.1 Square nonlinearity (SQNL)激活函数2.2 Piecewise Linear Unit (PLU)激活函数 3. 总结 1 引言 在前面的文章中已经介绍了介绍了一系列激活函数 (Sigmoid、Tanh、ReLU、Leaky ReLU、PR…
阅读更多...
【Android】相对布局（RelativeLayout）最全解析

【Android】相对布局（RelativeLayout）最全解析

【Android】相对布局&#xff08;RelativeLayout&#xff09;最全解析 一、相对布局&#xff08;RelativeLayout&#xff09;概述二、根据父容器定位三、根据兄弟控件定位 一、相对布局&#xff08;RelativeLayout&#xff09;概述 相对布局&#xff08;RelativeLayout&#x…
阅读更多...
Xtrfy M42W鼠标说明书

Xtrfy M42W鼠标说明书

下载:https://wwtf.lanzoul.com/ikXQh16gnmpe 密码:8h5t
阅读更多...
OpenCV实战（基础知识三）

OpenCV实战（基础知识三）

简介 OpenCV是一个流行的开源计算机视觉库&#xff0c;由英特尔公司发起发展。它提供了超过2500个优化算法和许多工具包&#xff0c;可用于灰度、彩色、深度、基于特征和运动跟踪等的图像处理和计算机视觉应用。OpenCV主要使用C语言编写&#xff0c;同时也支持Python、Java、C…
阅读更多...
RocketMQ零拷贝原理

RocketMQ零拷贝原理

1 PageCache ●由内存中的物理page组成&#xff0c;其内容对应磁盘上的block。 ●page cache的大小是动态变化的。 ●backing store&#xff1a;cache缓存的存储设备。 ●一个page通常包含多个block,而block不一定是连续的。 1.1读Cache ●当内核发起一个读请求时&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023