【C++】二叉搜索树+变身 = AVL树

头像
🚀个人主页：@小羊
🚀所属专栏：C++
很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~

动图描述

目录

  • 前言
  • 一、AVL树
  • 二、AVL树的实现
    • 2.1 平衡因子
    • 2.2 旋转处理
      • 2.2.1 左单旋：插入新节点后单纯的右边高
      • 2.2.2 右单旋：插入新节点后单纯的左边高
      • 2.2.3 左右旋：插入新节点后不是单纯的左边高
      • 2.2.4 右左旋：插入新节点后不是单纯的右边高
    • 2.3 验证AVL树的平衡
  • 三、完整代码

前言

本文仅适合了解二叉搜索树，但不了解AVL树底层原理的同学阅读哦。

本篇文章不会带你从头到尾实现AVL树，但会带你深入理解AVL树是怎么实现平衡的，怎么通过旋转变换实现保持平衡，以及实现平衡过程中的细节应该怎么处理等。

一、AVL树

前面的文章中我们分析过二叉搜索树的性能，得到的结果是理想情况下二叉搜索树的时间复杂度为O(LogN)，但在极端情况下（即树蜕化为单边树时），这些操作的时间复杂度会退化为O(n)，即使情况不那么极端，效率也不是特别高。

为了防止二叉搜索树出现一边偏高的情况，就需要想办法让二叉搜索树尽量保持平衡，所以两位苏联数学家（或称为俄罗斯数学家）G.M. Adelson-Velsky和E.M. Landis就发明了AVL树，其任何节点的两个子树的高度最大差别为1。

AVL树是具有一下性质的二叉搜索树：

  • 其左右子树都是AVL树
  • 左右子树高度差不超过1

二、AVL树的实现

本篇文章将沿用之前文章中Key-Value模型的代码，不再从底层开始实现，主要介绍在插入新节点后如何保持二叉搜索树的平衡问题。

2.1 平衡因子

如何保证AVL树的左右子树高度差不超过1？在AVL树的每个节点中存一个平衡因子，本文我们定义平衡因子 = 此节点右子树的高度 - 左子树的高度。

  • 插入在左子树，平衡因子 - -
  • 插入在右子树，平衡因子++

更新祖先节点的平衡因子时，我们首先需要找到祖先节点，因此每个节点中还需要增加一个指向父节点的指针。
按照我们的需求，其AVL树的节点可以定义为：

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子

	//构造
	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
}；

是否继续往上更新祖先节点的平衡因子，要看parent所在子树的高度是否发生变化。

插入新节点后其父节点的平衡因子有以下几种情况：

  1. parent的平衡因子 == 0
    parent的平衡因子更新前是 -1 / 1，新节点插入在矮的那边，高度不变，不再往上更新
  2. parent的平衡因子 == 1 / -1
    parent的平衡因子更新前是0，parent所在子树高度都变化了，需要往上更新
  3. parent的平衡因子 == 2 / -2
    parent的平衡因子更新前是 -1 / 1，插入新节点后树不再平衡，需要旋转处理
pcur = new Node(kv);
if (parent->_kv.first > kv.first)//判断新节点应该插入左还是右
{
	parent->_left = pcur;
}
else
{
	parent->_right = pcur;
}
pcur->_parent = parent;//与父节点链接关系

while (parent)//有可能更新到根节点去
{
	parent->_bf = parent->_left == pcur ? parent->_bf - 1 
	: parent->_bf + 1;
	if (parent->_bf == 0)//插入前后高度不变
	{
		break;
	}
	else if (parent->_bf == 1 || parent->_bf == -1)
	{
		//高度变了，继续往上更新
		pcur = parent;
		parent = parent->_parent;
	}
	else if (parent->_bf == 2 || parent->_bf == -2)
	{
		//插入节点后二叉树不平衡了，需要旋转处理
	}
	else
	{
		assert(false);//检测AVL树是否异常
	}
}

2.2 旋转处理

当二叉搜索树出现不平衡的情况时，需要旋转处理，对应插入后二叉搜索树的各种情况，主要有四种旋转的方式来保持平衡。

其中：

  • h代表子树的高度，可以是0、1、2…
  • 我们用能代表所有情况的四种类型的抽象图来研究旋转方式，单纯研究某几种情况没有意义

原则：

  1. 保持搜索树的性质
  2. 降低高度，控制平衡

2.2.1 左单旋：插入新节点后单纯的右边高

在这里插入图片描述

旋转处理过程中，我们主要关注三个节点（以上图为例）：10（标记为parent）、30（标记为subR）、b（标记为subLR）。

在旋转过程中，有以下几种情况需要考虑：

  1. subR的左孩子可能存在，也可能不存在
  2. parent可能是根节点，也可能是子树。如果是根节点，旋转完成后，要更新根节点；如果是子树，可能是某个节点的左子树，也可能是右子树
//左单旋
void RotateL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;//subRL是有可能为空的

	parent->_right = subRL;
	subR->_left = parent;
	Node* parentparent = parent->_parent;
	parent->_parent = subR;
	if (parentparent == nullptr)//subR有可能变成根
	{
		_root = subR;
	}
	else
	{
		if (parentparent->_left == parent)
		{
			parentparent->_left = subR;
		}
		else
		{
			parentparent->_right = subR;
		}
	}
	subR->_parent = parentparent;
	if (subRL)
	{
		subRL->_parent = parent;
	}

	parent->_bf = subR->_bf = 0;//更新平衡因子
}

旋转处理过程中主要是处理各节点的父节点指针的指向和平衡因子的更新。

2.2.2 右单旋：插入新节点后单纯的左边高

在这里插入图片描述

其处理方式和左单旋相似，可参考左单旋。

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

	parent->_left = subLR;
	subL->_right = parent;
	Node* parentparent = parent->_parent;
	parent->_parent = subL;
	if (parentparent == nullptr)
	{
		_root = subL;
	}
	else
	{
		if (parentparent->_left == parent)
		{
			parentparent->_left = subL;
		}
		else
		{
			parentparent->_right = subL;
		}
	}
	subL->_parent = parentparent;
	if (subLR)
	{
		subLR->_parent = parent;
	}
	subL->_bf = parent->_bf = 0;
}

2.2.3 左右旋：插入新节点后不是单纯的左边高

在这里插入图片描述

这种情况只用左旋或右旋只会原地打转，不能降低平衡。
我们需要先对subL进行左单旋，再对parent进行右单旋，最后更新平衡因子。

  • 双旋后平衡因子的更新要根据插入新节点后subLR的平衡因子来分情况讨论
  • 双旋最终结果是把subLR推到最上面，让其平衡因子为0
//左右旋
void RotateLR(Node* parent)
{
	Node* subL = parent->_left;
	Node* subLR = subL->_right;
	int bf = subLR->_bf;

	RotateL(parent->_left);
	RotateR(parent);

	if (bf == 0)
	{
		parent->_bf = 0;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == -1)
	{
		parent->_bf = 1;
		subL->_bf = 0;
		subLR->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = 0;
		subL->_bf = -1;
		subLR->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

2.2.4 右左旋：插入新节点后不是单纯的右边高

在这里插入图片描述

可参考左右旋。

//右左旋
void RotateRL(Node* parent)
{
	Node* subR = parent->_right;
	Node* subRL = subR->_left;
	int bf = subRL->_bf;

	RotateR(parent->_right);
	RotateL(parent);

	if (bf == 0)
	{
		parent->_bf = 0;
		subR->_bf = 0;
		subRL->_bf = 0;
	}
	else if (bf == -1)
	{
		parent->_bf = 0;
		subR->_bf = 1;
		subRL->_bf = 0;
	}
	else if (bf == 1)
	{
		parent->_bf = -1;
		subR->_bf = 0;
		subRL->_bf = 0;
	}
	else
	{
		assert(false);
	}
}

旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。

2.3 验证AVL树的平衡

我们可以分别计算出其左子树和右子树的高度，将其相减的值与节点中记录的平衡因子的值比较，看是否符合我们的预期。

int _Height(Node* root)
{
	if (root == nullptr)
	{
		return 0;
	}
	int leftheight = _Height(root->_left);
	int rightheight = _Height(root->_right);
	return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
}

bool _isBalanceTree(Node* root)
{
	if (root == nullptr)
	{
		return true;
	}
	int leftheight = _Height(root->_left);
	int rightheight = _Height(root->_right);
	int bf = rightheight - leftheight;
	if (abs(bf) > 1)
	{
		cout << root->_kv.first << "高度差异常" << endl;
		return false;
	}
	if (root->_bf != bf)
	{
		cout << root->_kv.first << "平衡因子异常" << endl;
		return false;
	}
	return _isBalanceTree(root->_left) && _isBalanceTree(root->_right);
}

三、完整代码

template<class K, class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	int _bf;//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_bf(0)
	{}
};

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:

	AVLTree() = default;

	AVLTree(const AVLTree<K, V>& t)
	{
		_root = copy(t._root);
	}

	AVLTree<K, V>& operator=(AVLTree<K, V> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~AVLTree()
	{
		Destroy(_root);
		_root = nullptr;
	}

	bool Find(const K& key)
	{
		Node* pcur = _root;
		while (pcur)
		{
			if (key < pcur->_kv.first)
			{
				pcur = pcur->_left;
			}
			else if (key > pcur->_kv.first)
			{
				pcur = pcur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Insert(const pair<K, V>& kv)
	{
		//没有节点时需要单独处理
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* pcur = _root;
		Node* parent = nullptr;
		while (pcur)
		{
			if (kv.first < pcur->_kv.first)
			{
				parent = pcur;
				pcur = pcur->_left;
			}
			else if (kv.first > pcur->_kv.first)
			{
				parent = pcur;
				pcur = pcur->_right;
			}
			else
			{
				return false;
			}
		}
		pcur = new Node(kv);
		if (parent->_kv.first > kv.first)//判断新节点应该插入左还是右
		{
			parent->_left = pcur;
		}
		else
		{
			parent->_right = pcur;
		}
		pcur->_parent = parent;//与父节点链接关系

		//更新平衡因子
		while (parent)//有可能更新到根节点去
		{
			parent->_bf = parent->_left == pcur ? parent->_bf - 1 : parent->_bf + 1;
			if (parent->_bf == 0)//插入前后高度不变
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//高度变了，继续往上更新
				pcur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//插入节点后二叉树不平衡了，需要旋转处理
				if (parent->_bf == 2 && pcur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && pcur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && pcur->_bf == -1)
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && pcur->_bf == 1)
				{
					RotateLR(parent);
				}
				break;//不管是哪种情况，旋转完后子树的高度没有变化，所以不再调整
			}
			else
			{
				assert(false);//检测AVL树是否异常
			}
		}
		return true;
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalanceTree()
	{
		return _isBalanceTree(_root);
	}

private:

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;//subRL是有可能为空的

		parent->_right = subRL;
		subR->_left = parent;
		Node* parentparent = parent->_parent;
		parent->_parent = subR;
		if (parentparent == nullptr)//subR有可能变成根
		{
			_root = subR;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				parentparent->_left = subR;
			}
			else
			{
				parentparent->_right = subR;
			}
		}
		subR->_parent = parentparent;
		if (subRL)
		{
			subRL->_parent = parent;
		}

		parent->_bf = subR->_bf = 0;//更新平衡因子
	}

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

		parent->_left = subLR;
		subL->_right = parent;
		Node* parentparent = parent->_parent;
		parent->_parent = subL;
		if (parentparent == nullptr)
		{
			_root = subL;
		}
		else
		{
			if (parentparent->_left == parent)
			{
				parentparent->_left = subL;
			}
			else
			{
				parentparent->_right = subL;
			}
		}
		subL->_parent = parentparent;
		if (subLR)
		{
			subLR->_parent = parent;
		}
		subL->_bf = parent->_bf = 0;
	}

	//左右旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == 0)
		{
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	//右左旋
	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	Node* copy(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* copynode = new Node(root->_kv);
		copynode->_left = copy(root->_left);
		copynode->_right = copy(root->_right);
		return copynode;
	}

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)//递归一定要有结束条件
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_InOrder(root->_right);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftheight = _Height(root->_left);
		int rightheight = _Height(root->_right);
		return leftheight > rightheight ? leftheight + 1 : rightheight + 1;
	}

	bool _isBalanceTree(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int leftheight = _Height(root->_left);
		int rightheight = _Height(root->_right);
		int bf = rightheight - leftheight;
		if (abs(bf) > 1)
		{
			cout << root->_kv.first << "高度差异常" << endl;
			return false;
		}
		if (root->_bf != bf)
		{
			cout << root->_kv.first << "平衡因子异常" << endl;
			return false;
		}
		return _isBalanceTree(root->_left) && _isBalanceTree(root->_right);
	}

private:
	Node* _root = nullptr;
};

本篇文章的分享就到这里了，如果您觉得在本文有所收获，还请留下您的三连支持哦~

头像

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

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

相关文章

光路科技TSN交换机：驱动自动驾驶技术革新，保障高精度实时数据传输

光路科技TSN交换机：驱动自动驾驶技术革新，保障高精度实时数据传输

自动驾驶技术正快速演进&#xff0c;对实时数据处理能力的需求激增。光路科技推出的TSN&#xff08;时间敏感网络&#xff09;交换机&#xff0c;在比亚迪最新车型中的成功应用&#xff0c;显著推动了这一领域的技术进步。 自动驾驶技术面临的挑战 自动驾驶系统需整合来自雷达…
阅读更多...
大模型基础：基本概念、Prompt、RAG、Agent及多模态

大模型基础：基本概念、Prompt、RAG、Agent及多模态

随着大模型的迅猛发展&#xff0c;LLM 作为人工智能的核心力量&#xff0c;正以前所未有的方式重塑着我们的生活、学习和工作。无论是智能语音助手、自动驾驶汽车&#xff0c;还是智能决策系统&#xff0c;大模型都是幕后英雄&#xff0c;让这些看似不可思议的事情变为可能。本…
阅读更多...
43 C 程序动态内存分配：内存区域划分、void 指针、内存分配相关函数（malloc、calloc、realloc、_msize、free）、内存泄漏

43 C 程序动态内存分配：内存区域划分、void 指针、内存分配相关函数（malloc、calloc、realloc、_msize、free）、内存泄漏

目录 1 C 程序内存区域划分 1.1 代码区 (Code Section) 1.2 全局/静态区 (Global/Static Section) 1.3 栈区 (Stack Section) 1.4 堆区 (Heap Section) 1.5 动态内存分配 2 void 指针&#xff08;无类型指针&#xff09; 2.1 void 指针介绍 2.2 void 指针的作用 2.3 …
阅读更多...
Java基本数据类型和String类型的转换

Java基本数据类型和String类型的转换

1.基本介绍 在程序开发中&#xff0c;我们经常需要将基本数据类型转换成String类型。或者将String类型转为基本数据类型。 2.基本类型转String类型 语法&#xff1a;将 基本数据类型的值 “” 即可 3.String类型转基本数据类型 语法&#xff1a;通过基本类型的包装类调用…
阅读更多...
【DataSophon】DataSophon1.2.1 整合Zeppelin并配置Hive|Trino|Spark解释器

【DataSophon】DataSophon1.2.1 整合Zeppelin并配置Hive|Trino|Spark解释器

目录 ​一、Zeppelin简介 二、实现步骤 2.1 Zeppelin包下载 2.2 work配置文件 三、配置常用解释器 3.1配置Hive解释器 3.2 配置trino解释器 3.3 配置Spark解释器 一、Zeppelin简介 Zeppelin是Apache基金会下的一个开源框架&#xff0c;它提供了一个数据可视化的框架&am…
阅读更多...
浏览器动态移动的小球源码分享

浏览器动态移动的小球源码分享

浏览器动态移动的小球源码分享 <script>(function(a){var width100,height100,borderRadius100,circlefunction(){};circle.prototype{color:function(){let colour "#"Math.floor(Math.random()*255).toString(16)Math.floor(Math.random()*255).toString…
阅读更多...
爬虫案例——爬取腾讯社招

爬虫案例——爬取腾讯社招

案例需求&#xff1a; 1.爬取腾讯社招的数据&#xff08;搜索 | 腾讯招聘&#xff09;包括岗位名称链接时间公司名称 2.爬取所有页&#xff08;翻页&#xff09; 3.利用jsonpath进行数据解析 4.保存数据&#xff1a;txt文本形式和excel文件两种形式 解析&#xff1a; 1.分…
阅读更多...
hdfs伪分布式集群搭建

hdfs伪分布式集群搭建

1 准备 vmware 虚拟三台centos系统的节点三台机器安装好jdk环境关闭防火墙&#xff08;端口太多&#xff0c;需要的自行去开关端口&#xff09;hadoop压缩包解压至三台服务器 可在一台节点上配置完成后克隆为三台节点 2 host修改 vi /etc/hosts在每个节点上添加三台机器的i…
阅读更多...
【Linux】Shell脚本基础+条件判断与循环控制

【Linux】Shell脚本基础+条件判断与循环控制

目录 一、介绍 1. Linux提供的Shell解析器 2. bash和sh关系 3. Centos默认的Shell解析器是bash 二、定义 1. 变量名的定义规则 2. 等号周围没有空格 3. 查看变量 4. 删除变量 5. 正确地定义数组 6. 将局部环境变量提升为全局 7. 正确选择引号 8. 特殊变量名 三…
阅读更多...
QT实现QMessageBox中文按钮

QT实现QMessageBox中文按钮

这是我记录Qt学习过程心得文章的第二篇&#xff0c;主要是为了方便QMessageBox弹出框的使用&#xff0c;通过自定义的方式&#xff0c;将其常用的功能&#xff0c;统一封装成一个函数&#xff0c;还是写在了Skysonya类里面。 实现代码&#xff1a; //中文提示对话框 bool Sky…
阅读更多...
Python爬虫使用示例-古诗词摘录

Python爬虫使用示例-古诗词摘录

一、分析需求 目标地址&#xff1a; https://www.sou-yun.cn/Query.aspx?typepoem&id二、提取诗句 import os import re import requests import parsel#url https://www.sou-yun.cn/PoemIndex.aspx?dynastyTang&author14976&typeJie urlhttps://www.sou-yun.…
阅读更多...
【PGCCC】在 Postgres 上构建图像搜索引擎

【PGCCC】在 Postgres 上构建图像搜索引擎

我最近看到的最有趣的电子商务功能之一是能够搜索与我手机上的图片相似的产品。例如&#xff0c;我可以拍一双鞋或其他产品的照片&#xff0c;然后搜索产品目录以查找类似商品。使用这样的功能可以是一个相当简单的项目&#xff0c;只要有合适的工具。如果我们可以将问题定义为…
阅读更多...
apisix云原生网关

apisix云原生网关

定义 企业级网关通过域名、路由将请求分发到对应的应用上&#xff0c;通常承载数千个服务的流量&#xff0c;对稳定性有较高要求。 CNCF全景图 选型 Kubernetes抽象出两个核心概念&#xff1a;Service&#xff0c;为多个Pod提供统一的访问入口&#xff1b;Ingress&#xff…
阅读更多...
汽车车轮平衡块行业前景：预计2030年全球市场规模将达到10亿美元

汽车车轮平衡块行业前景：预计2030年全球市场规模将达到10亿美元

汽车车轮平衡块&#xff0c;也称为轮胎平衡块&#xff0c;是一种安装在车轮上的配重部件。它的主要作用是帮助车轮在高速旋转状态下保持动平衡。当车轮高速旋转时&#xff0c;由于车轮的动态不平衡状态&#xff0c;会导致车辆在行驶中出现车轮抖动和方向盘震动的现象。汽车车轮…
阅读更多...
VSOMEIP代码阅读整理(1) - 网卡状态监听

VSOMEIP代码阅读整理(1) - 网卡状态监听

一. 概述 在routing进程所使用的配置文件中&#xff0c;存在如下配置项目&#xff1a;{"unicast" : "192.168.56.101",..."service-discovery" :{"enable" : "true","multicast" : "224.244.224.245",…
阅读更多...
【数据结构】栈和队列 + 经典算法题

【数据结构】栈和队列 + 经典算法题

目录 前言 一、栈 二、栈的实现 三、栈的循环遍历演示 四、栈的算法题 // 一、队列 二、队列的实现 三、使用演示 四、队列的算法题 总结 前言 本文完整实现了栈和队列的数据结构&#xff0c;以及栈和队列的一些经典算法题&#xff0c;让我们更加清楚了解这两种数据…
阅读更多...
昇思MindSpore进阶教程--数据处理性能优化(中)

昇思MindSpore进阶教程--数据处理性能优化(中)

大家好&#xff0c;我是刘明&#xff0c;明志科技创始人&#xff0c;华为昇思MindSpore布道师。 技术上主攻前端开发、鸿蒙开发和AI算法研究。 努力为大家带来持续的技术分享&#xff0c;如果你也喜欢我的文章&#xff0c;就点个关注吧 shuffle性能优化 shuffle操作主要是对有…
阅读更多...
PCB缺陷检测数据集 xml 可转yolo格式 ，共10688张图片

PCB缺陷检测数据集 xml 可转yolo格式 ，共10688张图片

PCB缺陷检测数据集&#xff08;yolov5,v7,v8&#xff09; 数据集总共有两个文件夹&#xff0c;一个是pcb整体标注&#xff0c;一个是pcb部分截图。 整体标注有6个分类&#xff0c;开路&#xff0c;短路等都已经标注&#xff0c;标注格式为xml&#xff0c;每个文件夹下有100多张…
阅读更多...
vue3 环境配置vue-i8n国际化

vue3 环境配置vue-i8n国际化

一.依赖和插件的安装 主要是vue-i18n和 vscode的自动化插件i18n Ally https://vue-i18n.intlify.dev/ npm install vue-i18n10 pnpm add vue-i18n10 yarn add vue-i18n10 vscode在应用商城中搜索i18n Ally&#xff1a;如图 二.实操 安装完以后在对应项目中的跟package.jso…
阅读更多...
探索Python的工业通信之光：pymodbus的奇妙之旅

探索Python的工业通信之光：pymodbus的奇妙之旅

文章目录 探索Python的工业通信之光&#xff1a;pymodbus的奇妙之旅背景&#xff1a;为何选择pymodbus&#xff1f;pymodbus是什么&#xff1f;如何安装pymodbus&#xff1f;5个简单的库函数使用方法3个场景使用示例常见bug及解决方案总结 探索Python的工业通信之光&#xff1a…
阅读更多...
最新文章

Copyright @ 2022~2023