红黑树的介绍与实现

前言

前面我们介绍了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;从而避免数…
阅读更多...
探地雷达正演模拟，基于时域有限差分方法，一

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

声明&#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;则算法可表示如下…
阅读更多...
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)选项。 将“快捷键”选项的状态设置为“…
阅读更多...
dos命令---根据端口查找进程

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

简介 在日常开发中&#xff0c;常常出现端口被占用的情况&#xff0c;导致程序运行报错&#xff0c;这时可以使用此命令查看哪个进程占用了端口 命令 netstat -ano | findstr 11434返回结果&#xff1a;
阅读更多...
【简单介绍下DALL-E2，什么是DALL-E2？】

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

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
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文档中…
阅读更多...
Matlab|混合策略改进的蝴蝶优化算法

Matlab|混合策略改进的蝴蝶优化算法

目录 1 主要内容 2 部分代码 3 程序结果 4 下载链接 1 主要内容 程序主要对蝴蝶算法&#xff08;BOA&#xff09;进行改进&#xff0c;参考文献《基于改进蝴蝶优化算法的冗余机器人逆运动学求解》&#xff0c;有如下改进策略&#xff1a; 改进1&#xff1a;采用反向学习策…
阅读更多...
手把手带你做一个自己的网络调试助手(1) - TCP服务器准备

手把手带你做一个自己的网络调试助手(1) - TCP服务器准备

程序设计流程图 TCP 服务器 ui界面搭建 Tcp服务器建立连接 - listen() connect() 1.在构造函数中进行如下初始化: 通过 QNetworkInterface 类的 allAddresses 这一API 获得可用IP地址&#xff08;包括IPv4 和 IPv6&#xff09; 然后通过QHostAddress类的 protocol 这一AP…
阅读更多...
使用vite从0开始搭建vue项目

使用vite从0开始搭建vue项目

使用Vite从0开始创建vue项目 第一步&#xff1a;创建项目目录 mkdir vue-demo -创建目录 cd vue-demo --进入项目 npm init -y --生成package.json文件 第二步&#xff1a;安装vite、typescript--ts、vue、vitejs/plugin-vue--对单文件组件、热重载、生产优化的支持 pnpm…
阅读更多...
“三夏”农忙：EasyCVR/EasyDSS无人机技术助推现代农业走向智能化

“三夏”农忙：EasyCVR/EasyDSS无人机技术助推现代农业走向智能化

随着科技的飞速发展&#xff0c;无人机技术已经逐渐渗透到我们生活的方方面面。其中&#xff0c;无人机在农业领域的应用尤为引人注目。它们不仅提高了农业生产的效率&#xff0c;还为农民带来了更便捷、更智能的种植方式。 无人机在农业应用场景中&#xff0c;通过搭载各种设备…
阅读更多...
【数据结构】 -- 堆 （堆排序）（TOP-K问题）

【数据结构】 -- 堆 （堆排序）（TOP-K问题）

引入 要学习堆&#xff0c;首先要先简单的了解一下二叉树&#xff0c;二叉树是一种常见的树形数据结构&#xff0c;每个节点最多有两个子节点&#xff0c;通常称为左子节点和右子节点。它具有以下特点&#xff1a; 根节点&#xff08;Root&#xff09;&#xff1a;树的顶部节…
阅读更多...
电脑回收站清空了怎么恢复回来？分享四个好用数据恢复方法

电脑回收站清空了怎么恢复回来？分享四个好用数据恢复方法

电脑回收站清空了还能恢复回来吗&#xff1f;在使用电脑过程中&#xff0c;很多小伙伴都不重视电脑的回收站,&#xff0c;有用的没用的文件都往里堆积。等空间不够的时候就去一股脑清空回收站。可有时候会发现自己还需要的文件在回收站里&#xff0c;可回收站已经被清空了……那…
阅读更多...
YoloV9改进策略：主干网络篇|MobileNetV4主干替换YoloV9的BackBone（独家原创）

YoloV9改进策略：主干网络篇|MobileNetV4主干替换YoloV9的BackBone（独家原创）

摘要 今年&#xff0c;轻量级王者MobileNetV4闪亮登场&#xff01;在我们这篇文章里&#xff0c;我们把MobileNetV4加入到了YoloV9中&#xff0c;对MobileNetV4的层数和卷积层核做了适当的修改&#xff0c;然后替换原有的BackBone。哈哈&#xff0c;你猜怎么着&#xff1f;效果…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023