红黑树的介绍与实现

前言

前面我们介绍了AVL树，AVL树是一棵非常自律的树，有着严格的高度可控制！但是正它的自律给他带来了另一个问题，即虽然他的查找效率很高，但是插入和删除由于旋转而导致效率没有那么高。我们上一期的结尾说过经常修改的话就不太适合AVL树了，而红黑树更加适合！OK，本期就来介绍一下赫赫有名的红黑树！

本期内容介绍

什么是红黑树

红黑树的实现

红黑树的效率分析以及应用

什么是红黑树？

红黑树是1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的 " 红黑树 "。

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

OK，这就是一棵红黑树：

最长节点的路径就是一黑一红的交替，最短的就是两黑：

红黑树的性质

1、每个结点要么是红色，要么是黑色

2、根节点是黑色

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

4、对于任意一个节点，从该结点到其所有的后代叶子结点的简单路径上，均包含相同的黑色结点

5、每个叶子结点就是黑色的（此处的叶子结点指的是空节点）

上面的这5条性质就是限制红黑树平衡的规则！其中4最重要的下来是3，基本所有的操作都是围着4进行的！！！

红黑树的实现

OK，上面介绍了红黑树是一种二叉搜索树，只不过是在每个结点添加了一个存储颜色的颜色位，所以它的大框架还是和搜索树一样的，所以我们就先搭一个框架出来！

enum Col//颜色
{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;//数据域Col _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:RBTree():_root(nullptr),_size(0){}private:Node* _root;//根节点size_t _size;//节点的数量
};

思考：新插入的节点应该是红色还是黑色？为什么？

新插入的节点一定是红色！

因为新插入的节点是红色可能违反性质3，但一定不违反性质4！

如果新插入的是黑色，一定违反性质4，也就是在部分子路径上增加了黑色节点。所以插入的新节点一定是红色，即使红色违反了性质3也是比较好控制的！

OK，这里依旧是采用的三叉链，原因是方便找父亲：

红黑树的插入

上面介绍了，红黑树的本质是一种二叉搜索树，所以先不管它的颜色和高度如何调节，先把搜索树的那一套给整出来：

bool Insert(const pair<K, V>& kv)
{Node* cur = _root;//当前节点Node* parent = nullptr;//插入位置的父亲//第一次插入if (_root == nullptr){_root = new Node(kv);_root->_col = BLACK;//根节点是黑色return true;}//寻找插入的位置while (cur){if (cur->_kv.first < kv.first)//插入节点的key比当前节点的key大{parent = cur;cur = cur->_right;//去右边找}else if(cur->_kv.first > kv.first)//插入节点的key比当前节点的key小{parent = cur;cur = cur->_left;//去左边找}else{return false;//插入的节点存在}}//找到插入位置cur = new Node(kv);//链接if (parent->_kv.first > cur->_kv.first){parent->_left = cur;}else{parent->_right = cur;}cur->_parent = parent;//颜色和高度调整//....return true;
}

OK，还是先来验证一下当前的逻辑对不对，所以走个中序看看是不是有序即可：由于中序要根节点，而类外面是无法访问的，所以我们还是和以前一样搞成子函数或提供get和set方法；这里就搞成子函数了：

中序遍历

void _InOrder(Node* root)
{if (root == nullptr)return;_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);
}

OK，没问题，下面我们就来讨论一下红黑树的维持平衡的方式:变色和旋转！

红黑树的变色和旋转

由于新插入的节点一定是红色的，此时分为两种情况，1、父亲为黑  2、父亲为红

如果父亲为黑，不违反任何性质，插入结束；

如果父亲为红，看看叔叔，此时叔叔有三类情况：1、叔叔存在且为红  2、叔叔不存在  3、叔叔存在为黑

如果，叔叔存在且为红：变色（将父亲和叔叔变黑色，将爷爷变红色），继续更新

如果，叔叔不存在或存在且为黑，旋转 + 变色（如果孩子是父亲的左/右，先对孩子父亲进行左/右旋，在对爷爷进行左/右）

OK，这里看着可能会有些迷，看看下面的导图会很清楚：

OK，理解了上述的表达，下面我来画图解释一下：

parent是黑色插入结束

parent为红，叔叔存在且为红（变色）

父亲和叔叔变黑，爷爷变红，继续向上更新

这里只画了parent在爷爷的左边的情况，如果parent在爷爷的右边和这个是一样的！

parent为红，叔叔不存在会存在为黑（变色 + 旋转）

如果parent在爷爷的左，且cur在父亲的左，对爷爷进行右单旋；

如果parent在爷爷的左，且cur在父亲的右，先对parent左单旋，在对爷爷进行右单旋；

如果parent在爷爷的右，且cur在父亲的右，对爷爷进行左单旋；

如果parent在爷爷的右，且cur在父亲的左，先对parent右单旋，在对爷爷进行左单旋；

OK，废话不多说直接上代码：

bool Insert(const pair<K, V>& kv)
{Node* cur = _root;//当前节点Node* parent = nullptr;//插入位置的父亲//第一次插入if (_root == nullptr){_root = new Node(kv);_size++;//插入成功节点数+1_root->_col = BLACK;//根节点是黑色return true;}//寻找插入的位置while (cur){if (cur->_kv.first < kv.first)//插入节点的key比当前节点的key大{parent = cur;cur = cur->_right;//去右边找}else if(cur->_kv.first > kv.first)//插入节点的key比当前节点的key小{parent = cur;cur = cur->_left;//去左边找}else{return false;//插入的节点存在}}//找到插入位置cur = new Node(kv);//链接if (parent->_kv.first > cur->_kv.first){parent->_left = cur;}else{parent->_right = cur;}cur->_parent = parent;//颜色和高度调整while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left)//父亲在爷爷的左{Node* uncle = grandfather->_right;//叔叔就是父亲的右//父亲存在且为红 -> 变色if (uncle && uncle->_col == RED){grandfather->_col = RED;parent->_col = uncle->_col = BLACK;//继续向上调整cur = grandfather;parent = cur->_parent;}else//叔叔不存在或存在但为黑 -> 变色 + 旋转{if (cur == parent->_left)//cur在父亲的左{//		   g//	   p		u// cRotateR(grandfather);//旋转parent->_col = BLACK;//变色grandfather->_col = RED;}else//cur在父亲的右{//		  g//	  p		  u//        cRotateL(parent);//旋转RotateR(grandfather);cur->_col = BLACK;//变色grandfather->_col = RED;}break;//旋转后不需要再向上更新了}}else//parent在爷爷的右{Node* uncle = grandfather->_left;//叔叔在父亲的左//叔叔存在且为红 -> 变色if (uncle && uncle->_col == RED){grandfather->_col = RED;parent->_col = uncle->_col = BLACK;//继续向上调整cur = grandfather;parent = cur->_parent;}else//叔叔不存在或存在但为黑 -> 变色 + 旋转{if (cur == parent->_left)//cur在父亲的左 {//		  g//	  u		   p//        cRotateR(parent);//旋转RotateL(grandfather);cur->_col = BLACK;//变色grandfather->_col = RED;}else{//		  g//	  u		   p//                 cRotateL(grandfather);//旋转parent->_col = BLACK;//变色grandfather->_col = RED;}break;//旋转后不需要再向上更新了}}}_root->_col = BLACK;//保证根节点永远是黑色_size++;//插入成功节点数+1return true;
}

旋转

红黑树的旋转没有，AVL的复杂，只有左右单旋且没有平衡因子！整体的逻辑和AVL一样的，这里不在详细介绍了！

void RotateR(Node* parent)
{Node* subL = parent->_left;//父亲的左Node* subLR = subL->_right;//左子树的右Node* ppNode = parent->_parent;//parent的父节点,方便旋转后的链接parent->_left = subLR;//将左子树的右给父亲的做if (subLR)subLR->_parent = parent;subL->_right = parent;//parent做左子树的右parent->_parent = subL;if (parent == _root)//parent是根{_root = subL;//此时的新根就是subLppNode = nullptr;}else//parent不是根{//将新的根连接到ppNodeif (ppNode->_left == parent){ppNode->_left = subL;}else{ppNode->_right = subL;}subL->_parent = ppNode;}
}void RotateL(Node* parent)
{Node* subR = parent->_right;//父亲的右Node* subRL = subR->_left;//右子树的左Node* ppNode = parent->_parent;//parent的父节点,方便旋转后的链接parent->_right = subRL;//将右子树的左连接到parent的右if (subRL)subRL->_parent = parent;subR->_left = parent;//parent连接到subR的左parent->_parent = subR;if (parent == _root)//parent是根{_root = subR;//此时的新根就是subRppNode = nullptr;}else//parent不是根{//将新的根连接到ppNodeif (ppNode->_left == parent){ppNode->_left = subR;}else{ppNode->_right = subR;}subR->_parent = ppNode;}
}

OK，我们验证一下，判断一下是否是平衡的：

是否平衡

先获取任意一条路径的黑色节点，然后通过dfs进行检查每个结点是不是符合红黑树的规则！

如果出现连续的红色节点，不符合！判断方式：当出现红色节点时，检查其父节点是否是红色的，如果是则不符合！

如走到空了，检查该条路径的黑色节点和一开始求出的是否一致，不一致则不符合！

当前节点符合，去检查其左右！

bool IsBalance()
{if (_root && _root->_col == RED){return false;//根为红，一定不是红黑树}int black = 0;//获取任意一条路径的黑色节点（这里是最左路）Node* cur = _root;while (cur){if (cur->_col == BLACK){black++;}cur = cur->_left;}return Check(_root, black, 0);
}
bool Check(Node* root, const int black, int num)
{if (root == nullptr){//当走到叶子节点的时候和其他路径的黑色节点的个数不一样if (black != num){return false;}return true;}//存在连续的红色节点if (root->_col == RED && root->_parent && root->_parent->_col == RED){cout << root->_kv.first << " ：存在连续的红色节点" << endl;return false;}//遇到黑色节点++if (root->_col == BLACK){num++;}//当前节点符合红黑树，它的左右子树也要都符合return Check(root->_left, black, num) && Check(root->_right, black, num);
}

OK，验证一下：

OK，么有问题！下面把其他的接口补一下！

Size

由于我们提前记录了_size所以直接返回成员_size即可！

size_t Size()
{return _size;
}

Find

和以前的搜索树一样，大了去右边找，小了去左边找！

Node* Find(const K& key)
{Node* cur = _root;while (cur){if (cur->_kv.first < key)//插入节点的key比当前节点的key大{cur = cur->_right;//去右边找}else if (cur->_kv.first > key)//插入节点的key比当前节点的key小{cur = cur->_left;//去左边找}else{return cur;//找到了}}return nullptr;//没找到
}

再来一组随机的测试用例：插入1亿个随机值，看看时间和是否平衡（注意这里一亿个节点在32位debug下可能内存空间不够，可以把他改成64的release地址空间大一点）

void Test()
{const int N = 100000000;vector<int> v;v.reserve(N);srand(time(0));for (size_t i = 0; i < N; i++){v.push_back(rand() + i);//cout << v.back() << endl;}size_t begin2 = clock();RBTree<int, int> t;for (auto e : v){t.Insert(make_pair(e, e));//cout << "Insert:" << e << "->" << t.IsBalance() << endl;}size_t end2 = clock();cout << "time :" << end2 - begin2 << endl;cout << t.IsBalance() << endl;
}

红黑树的删除：请参考这篇博客 ：红黑树的删除

全部源码

#pragma onceenum Col//颜色
{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;//数据域Col _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:RBTree():_root(nullptr),_size(0){}bool Insert(const pair<K, V>& kv){Node* cur = _root;//当前节点Node* parent = nullptr;//插入位置的父亲//第一次插入if (_root == nullptr){_root = new Node(kv);_size++;//插入成功节点数+1_root->_col = BLACK;//根节点是黑色return true;}//寻找插入的位置while (cur){if (cur->_kv.first < kv.first)//插入节点的key比当前节点的key大{parent = cur;cur = cur->_right;//去右边找}else if(cur->_kv.first > kv.first)//插入节点的key比当前节点的key小{parent = cur;cur = cur->_left;//去左边找}else{return false;//插入的节点存在}}//找到插入位置cur = new Node(kv);//链接if (parent->_kv.first > cur->_kv.first){parent->_left = cur;}else{parent->_right = cur;}cur->_parent = parent;//颜色和高度调整while (parent && parent->_col == RED){Node* grandfather = parent->_parent;if (parent == grandfather->_left)//父亲在爷爷的左{Node* uncle = grandfather->_right;//叔叔就是父亲的右//父亲存在且为红 -> 变色if (uncle && uncle->_col == RED){grandfather->_col = RED;parent->_col = uncle->_col = BLACK;//继续向上调整cur = grandfather;parent = cur->_parent;}else//叔叔不存在或存在但为黑 -> 变色 + 旋转{if (cur == parent->_left)//cur在父亲的左{//		   g//	   p		u// cRotateR(grandfather);//旋转parent->_col = BLACK;//变色grandfather->_col = RED;}else//cur在父亲的右{//		  g//	  p		  u//        cRotateL(parent);//旋转RotateR(grandfather);cur->_col = BLACK;//变色grandfather->_col = RED;}break;//旋转后不需要再向上更新了}}else//parent在爷爷的右{Node* uncle = grandfather->_left;//叔叔在父亲的左//叔叔存在且为红 -> 变色if (uncle && uncle->_col == RED){grandfather->_col = RED;parent->_col = uncle->_col = BLACK;//继续向上调整cur = grandfather;parent = cur->_parent;}else//叔叔不存在或存在但为黑 -> 变色 + 旋转{if (cur == parent->_left)//cur在父亲的左 {//		  g//	  u		   p//        cRotateR(parent);//旋转RotateL(grandfather);cur->_col = BLACK;//变色grandfather->_col = RED;}else{//		  g//	  u		   p//                 cRotateL(grandfather);//旋转parent->_col = BLACK;//变色grandfather->_col = RED;}break;//旋转后不需要再向上更新了}}}_root->_col = BLACK;//保证根节点永远是黑色_size++;//插入成功节点数+1return true;}Node* Find(const K& key){Node* cur = _root;while (cur){if (cur->_kv.first < key)//插入节点的key比当前节点的key大{cur = cur->_right;//去右边找}else if (cur->_kv.first > key)//插入节点的key比当前节点的key小{cur = cur->_left;//去左边找}else{return cur;//找到了}}return nullptr;//没找到}void InOrder(){return _InOrder(_root);}size_t Size(){return _size;}bool IsBalance(){if (_root && _root->_col == RED){return false;//根为红，一定不是红黑树}int black = 0;//获取任意一条路径的黑色节点（这里是最左路）Node* cur = _root;while (cur){if (cur->_col == BLACK){black++;}cur = cur->_left;}return Check(_root, black, 0);}private:void _InOrder(Node* root){if (root == nullptr)return;_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);}void RotateR(Node* parent){Node* subL = parent->_left;//父亲的左Node* subLR = subL->_right;//左子树的右Node* ppNode = parent->_parent;//parent的父节点,方便旋转后的链接parent->_left = subLR;//将左子树的右给父亲的做if (subLR)subLR->_parent = parent;subL->_right = parent;//parent做左子树的右parent->_parent = subL;if (parent == _root)//parent是根{_root = subL;//此时的新根就是subLppNode = nullptr;}else//parent不是根{//将新的根连接到ppNodeif (ppNode->_left == parent){ppNode->_left = subL;}else{ppNode->_right = subL;}subL->_parent = ppNode;}}void RotateL(Node* parent){Node* subR = parent->_right;//父亲的右Node* subRL = subR->_left;//右子树的左Node* ppNode = parent->_parent;//parent的父节点,方便旋转后的链接parent->_right = subRL;//将右子树的左连接到parent的右if (subRL)subRL->_parent = parent;subR->_left = parent;//parent连接到subR的左parent->_parent = subR;if (parent == _root)//parent是根{_root = subR;//此时的新根就是subRppNode = nullptr;}else//parent不是根{//将新的根连接到ppNodeif (ppNode->_left == parent){ppNode->_left = subR;}else{ppNode->_right = subR;}subR->_parent = ppNode;}}bool Check(Node* root, const int black, int num){if (root == nullptr){//当走到叶子节点的时候和其他路径的黑色节点的个数不一样if (black != num){return false;}return true;}//存在连续的红色节点if (root->_col == RED && root->_parent && root->_parent->_col == RED){cout << root->_kv.first << " ：存在连续的红色节点" << endl;return false;}//遇到黑色节点++if (root->_col == BLACK){num++;}//当前节点符合红黑树，它的左右子树也要都符合return Check(root->_left, black, num) && Check(root->_right, black, num);}private:Node* _root;//根节点size_t _size;//节点的数量
};

红黑树的效率分析以及应用

红黑树和AVL树的比较

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

红黑树的应用

C++的STL库中的map/set/multimap/multiset底层都是红黑树实现的

一些Java的库；例如: TreeMap和TreeSet等

一些Linux的内核，例如：进程调度等

OK，本期分享就到这里，好兄弟，我们下期再见！

结束语：简单的事重复做，重复的是坚持做！

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

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

相关文章

C语言：双链表

C语言：双链表

一、什么是双链表&#xff1f; 双链表&#xff0c;顾名思义&#xff0c;是一种每个节点都包含两个链接的链表&#xff1a;一个指向下一个节点&#xff0c;另一个指向前一个节点。这种结构使得双链表在遍历、插入和删除操作上都表现出色。与单链表相比&#xff0c;双链表不仅可以…
阅读更多...
【机器学习】【遗传算法】【项目实战】药品分拣的优化策略【附Python源码】

【机器学习】【遗传算法】【项目实战】药品分拣的优化策略【附Python源码】

仅供学习、参考使用 一、遗传算法简介 遗传算法&#xff08;Genetic Algorithm, GA&#xff09;是机器学习领域中常见的一类算法&#xff0c;其基本思想可以用下述流程图简要表示&#xff1a; &#xff08;图参考论文&#xff1a;Optimization of Worker Scheduling at Logi…
阅读更多...
DVB-S系统发射端Matlab仿真及FPGA实现

DVB-S系统发射端Matlab仿真及FPGA实现

DVB标准 Digital Video Broadcasting&#xff08;数字视频广播&#xff09;是一个完整的数字电视解决方案&#xff0c;其中包括DVB-C&#xff08;数字电视有线传输标准&#xff09;&#xff0c; DVB-T&#xff08;数字电视地面传输标准&#xff09;&#xff0c;DVB-S&#xff…
阅读更多...
正确理解iOS中的同步锁

正确理解iOS中的同步锁

在 iOS 开发中&#xff0c;同步锁&#xff08;synchronized lock&#xff09;是一种用于管理多线程访问共享资源的机制&#xff0c;而不是某一种特定类型的锁。它涵盖了多种具体实现和技术&#xff0c;用于确保同一时间只有一个线程能够访问某个共享资源&#xff0c;从而避免数…
阅读更多...
在 Linux 使用 cron 定时执行任务的注意事项

在 Linux 使用 cron 定时执行任务的注意事项

在 Linux 下想通过 cron 设置自动镜像备份文件&#xff0c;遇到很多挫折&#xff0c;最后成功&#xff0c;记录下几点注意事项。 尝试过程&#xff1a; 系统默认自带 cron&#xff0c;执行 crontab -e 添加开机启动任务。类似如下语句。 reboot rsync -a --delete /home/use…
阅读更多...
使用`LD_PRELOAD`和`jemalloc`实现C/C++信号的内存堆栈信息收集

使用`LD_PRELOAD`和`jemalloc`实现C/C++信号的内存堆栈信息收集

文章目录 0. 概要1. 编译jemalloc2. 编译钩子共享库liballoc_hook.so3. 使用LD_PRELOAD加载钩子库liballoc_hook.so测试3.1 设置环境变量3.2 使用LD_PRELOAD加载钩子库并运行程序3.3 发送SIGUSR1信号以触发堆栈信息打印3.4 使用jeprof解析heap堆栈信息文件 4. 示例程序example.…
阅读更多...
详细说说机器学习在医疗领域的应用

详细说说机器学习在医疗领域的应用

机器学习在医疗领域的应用广泛而深入&#xff0c;为医疗行业带来了显著的变革。以下是机器学习在医疗领域的主要应用方面&#xff1a; 个性化治疗&#xff1a; 机器学习能够根据病人的个体差异和基因组信息&#xff0c;帮助医生制定个性化的治疗方案。通过分析大规模的基因组数…
阅读更多...
探地雷达正演模拟，基于时域有限差分方法，一

探地雷达正演模拟，基于时域有限差分方法，一

声明&#xff1a;本博客中的公式均是在Word中使用AxMath写好后截图使用的&#xff0c;欢迎引用&#xff0c;但请标注来源。 本系列会有四篇博客&#xff1a; 第一篇内容&#xff1a; 1、基础知识掌握 2、Maxwell方法差分求解原理 第二篇内容&#xff1a; 1、基于C的TE波波…
阅读更多...
docker——基础知识

docker——基础知识

简介 一、什么是虚拟化和容器化 ​ 实体计算机叫做物理机&#xff0c;又时也称为寄主机&#xff1b; ​ 虚拟化&#xff1a;将一台计算机虚拟化为多态逻辑计算机&#xff1b; ​ 容器化&#xff1a;一种虚拟化技术&#xff0c;操作系统的虚拟化&#xff1b;将用户空间软件实…
阅读更多...
mongodb总概

mongodb总概

一、mongodb概述 mongodb是最流行的nosql数据库&#xff0c;由C语言编写。其功能非常丰富&#xff0c;包括: 面向集合文档的存储:适合存储Bson(json的扩展)形式的数据;格式自由&#xff0c;数据格式不固定&#xff0c;生产环境下修改结构都可以不影响程序运行;强大的查询语句…
阅读更多...
2 程序的灵魂—算法-2.2 简单算法举例-【例 2.3】

2 程序的灵魂—算法-2.2 简单算法举例-【例 2.3】

【例 2.3】判定 2000 — 2500 年中的每一年是否闰年&#xff0c;将结果输出。 润年的条件: 1. 能被 4 整除&#xff0c;但不能被 100 整除的年份&#xff1b; 2. 能被 100 整除&#xff0c;又能被 400 整除的年份&#xff1b; 设 y 为被检测的年份&#xff0c;则算法可表示如下…
阅读更多...
Element-UI全面入门与实战技巧

Element-UI全面入门与实战技巧

本文详细介绍了Element-UI的安装、配置、组件使用、布局技巧、交互设计、表单处理、主题定制等内容&#xff0c;旨在帮助开发者快速掌握Element-UI&#xff0c;并能在实际项目中灵活应用。 文章目录 一、Element-UI概述与安装1.1 Element-UI简介1.2 环境搭建1.3 安装Element-UI…
阅读更多...
C语言：定义和使用结构体变量

C语言：定义和使用结构体变量

定义和使用结构体变量 介绍基础用法1.定义结构体2. 声明结构体变量3. 初始化和访问结构体成员4. 使用指针访问结构体成员5. 使用结构体数组 高级用法6. 嵌套结构体7. 匿名结构体8. 结构体和动态内存分配9. 结构体作为函数参数按值传递按引用传递 介绍 在C语言中&#xff0c;结…
阅读更多...
Edge怎么关闭快捷键

Edge怎么关闭快捷键

Edge怎么关闭快捷键 在Edge浏览器中&#xff0c;你可以通过以下步骤关闭快捷键&#xff1a; 打开Edge浏览器&#xff0c;输入&#xff1a;edge://flags 并按下回车键。 在Flags页面中&#xff0c;搜索“快捷键”(Keyboard shortcuts)选项。 将“快捷键”选项的状态设置为“…
阅读更多...
Python 基于鲁棒核迭代最近点算法的点云精配准[Robust_ICP算法]

Python 基于鲁棒核迭代最近点算法的点云精配准[Robust_ICP算法]

点云配准鲁棒迭代最近点算法 一、概述1.1 定义1.2 算法步骤二、代码示例三、运行结果一、概述 1.1 定义 Robust_ICP（鲁棒迭代最近点算法）:是一种改进的ICP（Iterative Closest Point）算法，用于处理3D点云配准问题，特别是在存在噪声、外点（不匹配点）或数据分布不均等复杂…
阅读更多...
dos命令---根据端口查找进程

dos命令---根据端口查找进程

简介 在日常开发中&#xff0c;常常出现端口被占用的情况&#xff0c;导致程序运行报错&#xff0c;这时可以使用此命令查看哪个进程占用了端口 命令 netstat -ano | findstr 11434返回结果&#xff1a;
阅读更多...
关于利用hashcat破解WiFi数据包的操作记录

关于利用hashcat破解WiFi数据包的操作记录

准备数据包相关转换工具 ┌──(kali㉿kali)-[~/cap/3204] └─$ sudo apt-cache search hc | grep ^hc hcloud-cli - command-line interface for Hetzner Cloud hcxdumptool - Small tool to capture packets from wlan devices hcxkeys - Tools to generate plainmasterkey…
阅读更多...
【简单介绍下DALL-E2，什么是DALL-E2？】

【简单介绍下DALL-E2，什么是DALL-E2？】

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
【代码随想录算法训练营第37期 第三十二天 | LeetCode122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II】

【代码随想录算法训练营第37期 第三十二天 | LeetCode122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II】

代码随想录算法训练营第37期 第三十二天 | LeetCode122.买卖股票的最佳时机II、55. 跳跃游戏、45.跳跃游戏II 一、122.买卖股票的最佳时机II 解题代码C&#xff1a; class Solution { public:int maxProfit(vector<int>& prices) {int result 0;for(int i 1; i &…
阅读更多...
10.爬虫---XPath插件安装并解析爬取数据

10.爬虫---XPath插件安装并解析爬取数据

10.XPath插件安装并解析爬取数据 1.XPath简介2.XPath helper安装3.XPath 常用规则4.实例引入4.1 //匹配所有节点4.2 / 或 // 匹配子节点或子孙节点4.3 ..或 parent::匹配父节点4.4 匹配属性4.5 text()文本获取4.6 属性获取4.7 属性多值匹配 1.XPath简介 XPath是一门在XML文档中…
阅读更多...
最新文章

Copyright @ 2022~2023