数据结构/C++：红黑树

数据结构/C++：红黑树

    • 概念
    • 实现
      • 基本结构
      • 插入
        • uncle为红色节点
        • uncle为黑色节点
    • 总代码展示

概念

红黑树是一种二叉搜索树，一般的二叉搜索会发送不平衡现象，导致搜索效率下降，于是学者们开始探索如何让二叉搜索树保持平衡，这种树叫做自平衡二叉搜索树。起初学者发明了AVL树，其通过一定算法保持了二叉搜索树的严格平衡，不久后Rudolf Bayer发明了红黑树，红黑树的平衡是较为宽泛的，为了保持平衡，红黑树付出的代价比AVL树更小。因此红黑树被更为广泛的使用，比如Java，C++，python中，使用的自平衡二叉搜索树都是红黑树，而不是AVL树。

如果想了解AVL树，可以看这篇博客：[数据结构/C++：AVL树]

红黑树的要求如下：

红黑树中，最长路径的长度不会超过最短路径的两倍

先解释一下路径的概念：从根走到nullptr。
有不少人认为路径是从根走到叶子节点，这是不正确的。

红黑树用了五条规则来限制一棵树，从而达到以上要求：

  1. 每个节点不是红色就是黑色
  2. 根节点一定是黑色
  3. 不可以出现连续的红色节点（黑色可以连续出现）
  4. 每一条路径都包含相同数目的黑色节点
  5. nullptr视为黑色节点

只要满足以上五个条件，那么这棵树就是一颗红黑树，而且满足最长路径的长度不会超过最短路径的两倍。为什么呢？

五条规则中，我标红了3，4两条规则：

  1. 不可以出现连续的红色节点（黑色可以连续出现）
  2. 每一条路径都包含相同数目的黑色节点

由于每一条路径都必须包含相同数目的黑色节点，现在我们假设一棵红黑树，所有路径的黑色节点数目都是x，那么最短的路径长度就是全为黑色节点，长度为x。
如果想让一条路径变长，那么就只能插入更多的红色节点（因为黑色节点数目相同），但是红色节点又不能连续出现，所以只能是黑红黑红黑红黑红黑红......这样排列，一个黑节点匹配一个红节点，因此最长路径的长度就是黑色节点的两倍2x。
可以发现，红黑树通过这两条核心规则，保证了二叉搜索树的平衡。

比如以下就是一颗红黑树：
在这里插入图片描述

其最短路径为最左侧的路径，长度为2，即两个黑节点。
其最长路径为最右侧的路径，长度为4，即一红一黑排列。

要注意的是：不是所有的红黑树都会出现以上的全黑路径，或者一红一黑路径的，这只是极端情况。

接下来我们通过实现红黑树，来了解红黑树是如何自平衡的：

实现

基本结构

首先我们要在节点中加入一个成员来表示节点的颜色，颜色有红黑和黑色两种状态，这里我使用枚举来区分两者：

enum Colour
{RED,BLACK
};

在某些红黑树的实现中，使用bool值来表示红黑颜色，这也是可以的，但是本博客以枚举来表示颜色。

节点类：

template<class K, class V>
struct RBTreeNode
{RBTreeNode* _left;RBTreeNode* _right;RBTreeNode* _parent;pair<K, V> _kv;Colour _col;
};

_left：左子树
_right：右子树
_parent：父节点
_kv：节点存储的值
_col：该节点的颜色

节点类还需要一个构造函数进行初始化，现在的问题就是：新的节点要初始化为什么颜色？
先来考虑一下：插入红色节点和插入黑色节点，谁对红黑树影响大？
对于一棵红黑树，其所有路径的黑色节点数目都相同，如果我们在某一条路径末尾插入了黑色节点，那么整棵树的所有其它路径都会少一个黑节点。而插入红色节点只影响当前路径，所以新节点应该是红色节点。

构造函数：

RBTreeNode(const pair<K, V>& kv): _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _col(RED)//初始化为红节点
{}

接着就是红黑树本体，类中只存储一个根节点_root：

template<class K, class V>
class RBTree
{typedef RBTreeNode<K, V> Node;
private:Node* _root = nullptr;
}

现在我们有了红黑树的基本结构，接下来就实现它的插入操作：

插入

那么我们先写出当基本的二叉搜索树的插入代码逻辑，既然要插入，那么就要先找到合适的位置插入，代码如下：

bool Insert(const pair<K, V>& kv)
{if (_root == nullptr){_root = new Node(kv);_root->_col = BLACK;//保持根为黑节点}Node* cur = _root;Node* parent = nullptr;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->_left = cur;elseparent->_right = cur;cur->_parent = parent;//调整红黑树//......//......//......return true;
}

接下来，我先解析以上代码的逻辑：

if (_root == nullptr)
{_root = new Node(kv);_root->_col = BLACK;//保持根为黑节点
}

如果我们插入节点时，根节点_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;}
}

以上代码，是在找到合适的插入位置，当key大于当前节点cur->_kv.first < kv.first，那么cur就向左寻找，反之向右寻找。如果当前节点值等于key，那么说明该节点已经存在，返回false代表插入失败。当我们的cur为空指针，说明已经找到了插入的节点，此时跳出循环进行插入。

cur = new Node(kv);if (parent->_kv.first > kv.first)parent->_left = cur;
elseparent->_right = cur;cur->_parent = parent;

到达此处，说明前面已经找到插入的位置了，而parent节点就是插入位置的父亲节点。根据key的大小，来判断插入到左边还是右边，插入完成后，再让新节点的_parent指向parent。

至此我们就完成了插入操作，接下来就要根据不同情况对红黑树进行调整。

对于红黑树的插入，我们需要关注新节点的父亲parent，祖父grandfather，叔叔uncle三个节点：
在这里插入图片描述

  1. 先根据父亲节点的颜色，来判断是否需要调整

父亲节点为黑色：
在这里插入图片描述
新插入的节点默认为红色，所以新插入节点不会影响路径上黑色节点的数目，而parent是黑节点，我们也没有出现连续的红色节点，所以这种情况无需任何调整，直接插入就可以。

父亲节点为红色：
在这里插入图片描述
如果父亲节点为红色，我们就会出现连续的红色节点，这时我们就需要进行调整了

以上两种情况总结为：

当parent为黑色，直接插入
当parent为红色，插入后需要进行调整

当前的代码为：

在这里插入代码片

当parent为红色，我们就需要再根据uncle的颜色，将插入分类两类：uncle为红色以及uncle为黑色。
在这里插入图片描述
值得注意的是：由于parent是红色节点，此时的grandfather一定是黑色节点，因为不能出现连续红色节点
这两种情况的操作不同，我们先看到uncle为红色的情况：

uncle为红色节点

当uncle节点为红色，此时需要进行变色

变色如下：
在这里插入图片描述

由于新插入了红色的cur节点，此时parent与cur出现了连续的红色节点，于是我们将parent改为黑色。但是此时以parent为根的所有路径就会多出一个黑节点，于是把grandfather变为红色，来抵消这个新增的黑节点。但是此时以uncle为根的路径又会少一个黑节点，于是把uncle变黑。

但是我们将grandfather变为了红色，这有可能会影响到上一层节点，比如这样：
在这里插入图片描述
我们把grandfather变红之后，又出现了两个红色节点相连的情况，所以我们要写一个while循环，来反复向上检查。

当前代码如下：

while (parent && parent->_col == RED)//只有parent为红，才更新 (parent可能不存在)
{Node* grandfather = parent->_parent;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;}else//uncle为黑节点 {//其它处理}}else{Node* uncle = grandfather->_left;//uncle存在且为红节点if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else//uncle为黑节点 {//其它处理}}
}_root->_col = BLACK;//在循环内部不判断root情况，统一处理

代码解析：

while (parent && parent->_col == RED)

该代码用于检测cur的parent的颜色，通过我们前面的推导，如果parent为红色才需要调整，因此进入循环的条件之一是parent为红色。另外的parent有可能为nullptr，此时我们要避免访问空指针，所以空指针也不能进循环

if (parent == grandfather->_left)
{  }
else
{ }

这一段代码是在检测parent 节点是grandfather的左子树还是右子树，这将涉及到我们如何找uncle以及下一种情况的调整，此时我们要分类讨论。当parent == grandfather->_left成立，那么uncle就是grandfather的右子树：Node* uncle = grandfather->_right;，反之就是左子树

if (uncle && uncle->_col == RED)
{parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;
}

我们找到uncle后，如果uncle是红色，那么直接进行变色操作，把parent和uncle的颜色变为黑色，grandfather变为红色。
随后由于我们的变色操作可能会影响上一层，此时调整节点，进入下一次while循环

在整个while循环外侧，还有一句代码：

_root->_col = BLACK;

这是因为我们在先前的while循环中，有可能出现对_root节点的操作，导致_root的颜色改变，而_root需要保持黑色。如果我们在循环内部，每一次都检测_root有点麻烦了，于是我们直接在每一次调整完节点后，把_root强行矫正为黑色

至此我们就讨论完了uncle为红色节点的情况，接下来我们就讨论uncle为黑色节点：

uncle为黑色节点

由于红黑树中，nullptr也算作黑色节点，所以uncle为黑色分为以下两种情况：

  1. uncle为空指针
  2. uncle不为空指针

图示如下：
在这里插入图片描述

如果 uncle为空指针，那么cur一定是新插入的节点。

因为如果cur不是新插入的节点，那么cur和parent一定有一个原先是黑色节点，不然会出现连续的红色节点。但是如果cur和parent有一个是黑色节点，那么grandfather的左子树就比右子树多出一个黑节点，这就违背了红黑树规则。无论怎样，原先的树都不可能符合规则，所以cur一定是新插入的节点，破坏了规则。

如果 uncle不为空指针，那么cur一定是从黑色节点变成的红色节点（不是新插入的）。

因为如果uncle存在，那么grandfather的右子树就存在一个黑节点，而parent是红节点，所以cur和parent的右子树中都至少有一个黑节点，才能保证每一条路径黑节点数目相同。因此cur原先一定是黑节点，是因为cur下层插入了新节点，然后通过while循环向上走，影响到了当前层。

对于这种uncle为黑色的情况，我们需要通过旋转+变色来维持红黑树。

旋转又分为单旋和双旋：

当cur与parent的关系和parent与grandfather的关系一致时，需要进行单旋

比如我们刚刚的情况：
在这里插入图片描述
cur是parent的左子树，parent是grandfather的左子树，关系一致。
我们需要对其进行右单旋+变色：
在这里插入图片描述
这个旋转的算法在此我就不过多讲解了，可以去AVL树的博客中了解。我重点讲解一下变色和旋转的合理性：

一次插入过程中，走到这一步，说明前面一定经过了uncle为红色的情况，而对uncle为红色的情况进行变色并不会对任何路径的黑色节点数目造成影响，因此目前还是符合黑色节点数目相同规则的。
同为parent的子树，以cur和C为根的路径，黑节点数目相同
同为grandfather的子树，以parent和uncle为根的路径黑节点数目相同
而parent是红色节点，所以cur，C以及uncle为根的路径，黑节点数目都相同

进行单旋，会把c树交给grandfather做子树，而c与uncle为根的路径黑节点数目相同，不违背规则（旋转的合理性）

旋转后，parent作新根，grandfather与cur作为左右子树grandfather为根的路径，整体上就会比以cur为根的路径多出一个黑节点(即grandfather本身)
因此，将grandfather改为红节点，来平衡parent左右子树的黑节点
而红色节点不能连续出现，再把parent改为黑节点

当cur与parent的关系和parent与grandfather的关系不一致时，需要进行双旋

在这里插入图片描述
以上结构中，cur是parent的左子树，parent是grandfather的右子树，关系不一致，要进行双旋。
同样的，讲解一下变色和旋转的合理性：

一次插入过程中，走到这一步，说明前面一定经过了uncle为红色的情况，而对uncle为红色的情况进行变色并不会对任何路径的黑色节点数目造成影响，因此目前还是符合黑色节点数目相同规则的。
同为parent的子树，以cur和A为根的路径，黑节点数目相同
同为cur的子树，以B和C为根的路径，黑节点数目相同
由于cur是红节点，所以以A，B，C为根的路径，黑节点数目相同
相同的手段，由于parent是红节点，所以A与uncle为根的路径的黑节点数目相同
因此A，B，C，uncle为根的路径，黑节点数目都相同

进行双旋，会把C子树交给grandfather做子树，而C与uncle黑节点数目相同，不违背规则也会把B交给parent做子树
A与B黑节点数目相同，不违背规则
旋转后，cur作新根，grandfather与parent作为左右子树grandfather为根的路径，整体上就会比以parent为根的路径多出一个黑节点(grandfather本身)
因此，将grandfather改为红节点，来平衡cur左右子树的黑节点而红色节点不能连续出现，再把cur改为黑节点

以上单旋和双旋的变色，看似复杂，其实最后都是把新根的颜色变为黑色，新根的左右子树变为红色。由于我们旋转后，新根都是黑节点，所以不会影响上层，可以直接跳出循环。

代码如下：

当parent == grandfather->_left：

else//uncle为黑节点 (旋转)
{if (cur == parent->_left){RotateR(grandfather);//右单旋parent->_col = BLACK;//变色grandfather->_col = RED;//变色}else{RotateL(parent);//左右双旋 - 左单旋RotateR(grandfather);//左右双旋 - 右单旋cur->_col = BLACK;//变色grandfather->_col = RED;//变色}break;//旋转后一定平衡
}

当parent == grandfather->_right：

else//uncle为黑节点 (旋转)
{if (cur == parent->_right){RotateL(grandfather);//左单旋parent->_col = BLACK;//变色grandfather->_col = RED;//变色}else{RotateR(parent);//右左双旋 - 右单旋RotateL(grandfather);//右左双旋 - 左单旋cur->_col = BLACK;//变色grandfather->_col = RED;//变色}break;//旋转后一定平衡
}

insert总代码：

bool Insert(const pair<K, V>& kv)
{if (_root == nullptr){_root = new Node(kv);_root->_col = BLACK;//保持根为黑节点}Node* cur = _root;Node* parent = nullptr;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->_left = cur;elseparent->_right = cur;cur->_parent = parent;while (parent && parent->_col == RED)//只有parent为红，才更新 (parent可能不存在){Node* grandfather = parent->_parent;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;}else//uncle不存在或为黑节点 (旋转){if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else{RotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;//旋转后一定平衡}}else{Node* uncle = grandfather->_left;//uncle存在且为红节点if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else//uncle不存在或为黑节点 (旋转){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;//在循环内部不判断root情况，统一处理return true;
}

总代码展示

红黑树总代码：
RBTree.h：

#pragma once
#include <iostream>
#include <assert.h>
using namespace std;enum Colour
{RED,BLACK
};template<class K, class V>
struct RBTreeNode
{RBTreeNode* _left;RBTreeNode* _right;RBTreeNode* _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;//保持根为黑节点}Node* cur = _root;Node* parent = nullptr;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->_left = cur;elseparent->_right = cur;cur->_parent = parent;while (parent && parent->_col == RED)//只有parent为红，才更新 (parent可能不存在){Node* grandfather = parent->_parent;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;}else//uncle不存在或为黑节点 (旋转){if (cur == parent->_left){RotateR(grandfather);parent->_col = BLACK;grandfather->_col = RED;}else{RotateL(parent);RotateR(grandfather);cur->_col = BLACK;grandfather->_col = RED;}break;//旋转后一定平衡}}else{Node* uncle = grandfather->_left;//uncle存在且为红节点if (uncle && uncle->_col == RED){parent->_col = uncle->_col = BLACK;grandfather->_col = RED;cur = grandfather;parent = cur->_parent;}else//uncle不存在或为黑节点 (旋转){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;//在循环内部不判断root情况，统一处理return true;}//左单旋void RotateL(Node* parent){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 = subR;if (parent == _root){_root = subR;subR->_parent = nullptr;}else{if (ppNode->_left == parent)ppNode->_left = subR;elseppNode->_right = subR;subR->_parent = ppNode;}}//右单旋void RotateR(Node* parent){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;elseppNode->_right = subL;subL->_parent = ppNode;}}size_t Size(){return _Size(_root);}size_t _Size(Node* root){if (root == nullptr)return 0;;return _Size(root->_left) + _Size(root->_right) + 1;}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;}//中序void InOrder(){_InOrder(_root);cout << "end" << endl;}int Height(){return _Height(_root);}private://中序void _InOrder(Node* root){if (root == nullptr)return;_InOrder(root->_left);cout << root->_kv.first << " - ";_InOrder(root->_right);}//求高度int _Height(Node* root){if (root == nullptr)return 0;return max(Height(root->_left), Height(root->_right)) + 1;}Node* _root = nullptr;
};

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

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

相关文章

unity学习（60）——选择角色界面--MapHandler2-MapHandler.cs

unity学习（60）——选择角色界面--MapHandler2-MapHandler.cs

1.新建一个脚本&#xff0c;里面有static变量loadingPlayerList using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks;namespace Assets.Scripts.Model {internal class LoadData{public static List<Pl…
阅读更多...
R语言中的常用基础绘图函数 直方图，箱线图，条形图，散点图

R语言中的常用基础绘图函数 直方图，箱线图，条形图，散点图

目录 R语言中的绘图参数 绘图函数 1.plot函数绘制散点图 2.hist函数绘制直方图 如何修饰直方图? 如何在直方图上标注各组频数&#xff1f; 使用text函数把某些信息标注在直方图上 如何在直方图上添加概率密度曲线&#xff1f; 3.boxplot函数绘制箱线图 4.barplot函数…
阅读更多...
JVM虚拟机：通过jconsole远程连接解决JVM报错

JVM虚拟机：通过jconsole远程连接解决JVM报错

本文重点 前面我们介绍过的一些工具都是使用命令行的方式来帮助我们完成&#xff0c;本文我们将使用一种图形化界面的方式来远程连接&#xff0c;然后完成关于JVM的检测任务。 jconsole jconsole是一个JVM的检测工具&#xff0c;这个工具任何安装了Java的电脑上都有的&#…
阅读更多...
手机网络连接性能API接口：查询手机网络连接性能状态

手机网络连接性能API接口：查询手机网络连接性能状态

手机在网状态查询服务是一项非常方便的服务&#xff0c;可以帮助我们随时了解一个手机号码的在网状态。不论是查询自己的手机号码&#xff0c;还是查询他人的手机号码&#xff0c;这个服务都可以帮助我们获取准确的信息。今天&#xff0c;我想和大家介绍一个非常好用的手机在网…
阅读更多...
GitHub Actions持续部署

GitHub Actions持续部署

一、概述 1.1Github Action介绍 什么是Github Action ? GitHub Actions是GitHub提供的CI/CD&#xff08;持续集成/持续部署&#xff09;服务。它允许你在GitHub仓库中自动化、定制和执行你的软件开发工作流。你可以发现、创建和分享用于执行任何你想要的工作的操作&#xff0…
阅读更多...
《计算机视觉中的深度学习》之目标检测算法原理

《计算机视觉中的深度学习》之目标检测算法原理

参考&#xff1a;《计算机视觉中的深度学习》 概述 目标检测的挑战&#xff1a; 减少目标定位的准确度减少背景干扰提高目标定位的准确度 目标检测系统常用评价指标&#xff1a;检测速度和精度 提高精度&#xff1a;有效排除背景&#xff0c;光照和噪声的影响 提高检测速度…
阅读更多...
Spark-Transformation以及Action开发实战

Spark-Transformation以及Action开发实战

文章目录 创建RDDTransformation以及ActionTransformation开发Action开发RDD持久化共享变量创建RDD RDD是Spark的编程核心，在进行Spark编程是，首要任务就是创建一个初始的RDDSpark提供三种创建RDD方式：集合、本地文件、HDFS文件 集合：主要用于本地测试，在实际部署到集群运…
阅读更多...
FAN3224TMX门极驱动器中文资料PDF数据手册引脚图参数价格图片功能特性

FAN3224TMX门极驱动器中文资料PDF数据手册引脚图参数价格图片功能特性

产品概述&#xff1a; FAN3223-25 系列双 4A 门极驱动器以较短的开关间隔提供高峰值电流脉冲&#xff0c;用于在低侧开关应用中驱动 N 沟道增强模式 MOSFET。该驱动器提供 TTL 或 CMOS 输入阈值。内部电路将输出保持在低电平&#xff0c;直到电源电压处于运行范围内&#xff0…
阅读更多...
在Docker容器中配置`code-server`以访问宿主机的Docker环境

在Docker容器中配置`code-server`以访问宿主机的Docker环境

在Docker容器中配置code-server以访问宿主机的Docker环境 部分内容使用gpt生成&#xff0c;但经过测试可用。 要在code-server容器内部安全地管理和访问宿主机的Docker环境&#xff08;主要是为了访问宿主机的texlive&#xff09;&#xff0c;遵循以下步骤能够确保流畅的集成和…
阅读更多...
R语言深度学习-5-深度前馈神经网络

R语言深度学习-5-深度前馈神经网络

本教程参考《RDeepLearningEssential》 本篇我们将学习如何建立并训练深度预测模型。我们将关注深度前馈神经网络 5.1 深度前馈神经网络 我们还是使用之前提到的H2O包&#xff0c;详细可以见之前的博客&#xff1a;R语言深度学习-1-深度学习入门&#xff08;H2O包安装报错解决…
阅读更多...
[scikit-learn] 第一章 初识scikit-learn及内置数据集介绍

[scikit-learn] 第一章 初识scikit-learn及内置数据集介绍

文章目录 菜鸡镇贴&#xff01;&#xff01;&#xff01;scikit-learn 简要介绍scikit-learn 安装scikit-learn 数据集介绍数据集API介绍LoadersSamples generator 导入数据集demo 菜鸡镇贴&#xff01;&#xff01;&#xff01; scikit-learn 简要介绍 ​ Scikit learn是一个…
阅读更多...
RK3568平台开发系列讲解（基础篇）内核是如何发送事件到用户空间

RK3568平台开发系列讲解（基础篇）内核是如何发送事件到用户空间

🚀返回专栏总目录 文章目录 一、相关接口函数二、udevadm 命令三、实验沉淀、分享、成长，让自己和他人都能有所收获！😄 一、相关接口函数 kobject_uevent 是 Linux 内核中的一个函数， 用于生成和发送 uevent 事件。 它是 udev 和其他设备管理工具与内核通信的一种方式。…
阅读更多...
SDN网络简单认识（1）——概述

SDN网络简单认识（1）——概述

一、概述 软件定义网络&#xff08;Software Defined Networking&#xff0c;SDN&#xff09;是一种网络架构理念&#xff0c;旨在使网络灵活和可编程&#xff0c;从而更好地支持动态和高度可扩展的计算环境。SDN通过抽象网络的控制层&#xff08;决策层&#xff09;和数据层&a…
阅读更多...
面试经典-MySQL篇

面试经典-MySQL篇

一、MySQL组成 MySQL数据库的连接池&#xff1a;由一个线程来监听一个连接上请求以及读取请求数据&#xff0c;解析出来一条我们发送过去的SQL语句SQL接口&#xff1a;负责处理接收到的SQL语句查询解析器&#xff1a;让MySQL能看懂SQL语句查询优化器&#xff1a;选择最优的查询…
阅读更多...
OpenCV 图像重映射函数remap()实例详解

OpenCV 图像重映射函数remap()实例详解

OpenCV 图像重映射函数remap()对图像应用通用几何变换。其原型如下&#xff1a; void remap(InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation&#xff0c; int borderMode BORDER_CONSTANT&#xff0c; const Scalar & borde…
阅读更多...
LeetCode 189.轮转数组

LeetCode 189.轮转数组

题目&#xff1a;给定一个整数数组 nums&#xff0c;将数组中的元素向右轮转 k 个位置&#xff0c;其中 k 是非负数。 思路&#xff1a; 代码&#xff1a; class Solution {public void rotate(int[] nums, int k) {int n nums.length;k k % n;reverse(nums, 0, n);revers…
阅读更多...
吴恩达deeplearning.ai:使用多个决策树随机森林

吴恩达deeplearning.ai:使用多个决策树随机森林

以下内容有任何不理解可以翻看我之前的博客哦&#xff1a;吴恩达deeplearning.ai专栏 文章目录 为什么要使用树集合使用多个决策树(Tree Ensemble)有放回抽样随机森林XGBoost(eXtream Gradient Boosting)XGBoost的库实现何时使用决策树决策树和树集合神经网络 使用单个决策树的…
阅读更多...
Spark-Scala语言实战（2）（在IDEA中安装Scala，超详细配图）

Spark-Scala语言实战（2）（在IDEA中安装Scala，超详细配图）

之前的文章中&#xff0c;我们学习了如何在windows下下载及使用Scala&#xff0c;但那对一个真正想深入学习Scala的人来说&#xff0c;是不够的&#xff0c;今天我会给大家带来如何在IDEA中安装Scala。同时&#xff0c;希望我的文章能帮助到你&#xff0c;如果觉得我的文章写的…
阅读更多...
Javaweb--CSS

Javaweb--CSS

一&#xff1a;概述 CSS &#xff08;Cascading Style Sheet&#xff08;层叠样式表&#xff09;&#xff09;是一门语言&#xff0c;用于控制网页表现。 W3C标准规定了网页是由以下组成&#xff1a; 结构&#xff1a;HTML 表现&#xff1a;CSS 行为&#xff1a;JavaScrip…
阅读更多...
分布式文件存储与数据缓存（一）| FastDFS

分布式文件存储与数据缓存（一）| FastDFS

目录 分布式文件系统FastDFS概述_简介FastDFS特性&#xff1a;分布式文件服务提供商 FastDFS概述_核心概念trackerstorageclientgroup FastDFS概述_上传机制内部机制如下 FastDFS概述_下载机制内部机制如下 FastDFS环境搭建_Linux下载安装gcc下载安装FastDFS下载安装FastDFS依赖…
阅读更多...
最新文章

Copyright @ 2022~2023