【C++进阶】AVL树

news2024/11/25 3:45:08

0.前言

前面我们已经学习过二叉搜索树了，但如果我们是用二叉搜索树来封装map和set等关联式容器是有缺陷的，很可能会退化为单分支的情况，那样效率就极低了，那么有没有方法来弥补二叉搜索树的缺陷呢？

那么AVL树就出现了，通过AVL树的右单旋、左单旋、左右单旋，右左单旋等操作来防止二叉搜索树退化为单分支的情况出现。

因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
AVL树也是以这两位大佬名字的首字母来命名的。

1.AVL树的概念

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树是AVL树：

  • 它的左右子树都是AVL树
  • 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
     

我们这里使用的平衡因子是右子树高度 - 左子树高度。 

 

2.AVL树节点的定义

代码如下：

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;	//该节点的左孩子
	AVLTreeNode<K, V>* _right;	//该节点的右孩子
	AVLTreeNode<K, V>* _parent;	//该节点的双亲

	pair<K, V>  _kv;	//该节点的key和value

	int _bf; //balance factor 平衡因子
	AVLTreeNode(const pair<K, V>& kv)	//该节点初始化
		:_left(nullptr)  
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)  
		, _bf(0)
	{}
};

3.AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么
AVL树的插入过程可以分为两步：

  1. 按照二叉搜索树的方式插入新节点
  2. 调整节点的平衡因子
     

插入思路：

 1.按照搜索树规则插入

2.更新插入节点的祖先节点的平衡因子

        a.插入父亲的右边，父亲的平衡因子--

        b.插入父亲的左边，父亲的平衡因子++

        c.父亲平衡因子 == 0， 父亲所在子树高度不变，不再继续往上更新。插入结束

        d.父亲平衡因子 == 1 or -1， 父亲所在子树高度变了，继续往上更新。

        e.父亲平衡因子 == 2 or -2， 父亲所在子树已经不平衡了，需要旋转处理。

更新中不可能出现其他值，插入之前树是AVL树，平衡因子要么是1 -1 0， ++ --

最多就是c/d/e三种情况。

 代码如下：

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _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;
			}
		}

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

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				//更新结束
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				//继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == -2 || parent->_bf == 2)
			{
				//当前子树出现了问题，需要旋转平衡一下
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					//右单旋
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					//左单旋
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					//左右双旋
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					//右左双旋
					//RotateRL(parent);
				}
				break;
			}
			else
			{
				//理论上不会出现这种情况，但仍要判断，大佬都不能保证自己的代码没有bug
				assert(false);
			}

		}
		return true;
	}

4.AVL树的旋转

4.1 右单旋

插入新节点要插入较高左子树的左侧（左左）-》右单旋

图形解析：

 实现代码如下：

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)	//subLR有可能为空，不为空时才能调整subLR的父节点
			subLR->_parent = parent;
		subL->_right = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		subL->_bf = parent->_bf = 0;
	}

4.2 左单旋

插入新节点要插入较高右子树的右侧（右右）-》左单旋

图形解析：

 代码如下：

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)	//subRL有可能为空，不为空时才能调整subRL的父节点
			subRL->_parent = parent;
		subR->_left = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		subR->_bf = parent->_bf = 0;
	}

4.3 左右双旋

插入新节点要插入较高左子树的右侧（左右）-》左右双旋

图形解析：

对于插入的位置根据h的高度和插入的位置时的平衡因子出现的最终的结果可分为三种情况：

1.h == 0

        60自己就是新增节点。bf == 0

此时的平衡因子为，30 60 90节点都为0。

2.h > 0

        a.新增节点插入的是60的左子树中 bf == -1

此时的平衡因子为，30节点为0,90为0,60为1

        b.新增节点插入的是60的右子树中bf == 1

此时的平衡因子为，30节点为-1,90为0,60为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)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			//理论上不会出现的情况
			assert(false);
		}
	}

4.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;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			//理论上不会出现的情况
			assert(false);
		}
	}


总结：
假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑
1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR
当pSubR的平衡因子为1时，执行左单旋
当pSubR的平衡因子为-1时，执行右左双旋
2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL
当pSubL的平衡因子为-1是，执行右单旋
当pSubL的平衡因子为1时，执行左右双旋
旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。
 

5.AVL树的验证

5.1 验证其是否为二叉搜索树

给一个序列进行一次中序遍历，看是否有序，有序即为二叉搜索树。

void TestAVLTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert({ e,e });
	}

	t1.InOrder();
}

5.2 验证其是否为平衡树

	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		//不平衡
		if (abs(leftHeight - rightHeight) >= 2)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		//顺便检查一下平衡因子是否正确
		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		return _IsBalance(root->_left)
			&& _IsBalance(root->right);
	}

6.AVL树的删除（了解）

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

7.AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即logN。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

 8.AVL树的整体模拟代码实现

#pragma once
#include<iostream>
using namespace std;
#include<assert.h>

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;	//该节点的左孩子
	AVLTreeNode<K, V>* _right;	//该节点的右孩子
	AVLTreeNode<K, V>* _parent;	//该节点的双亲

	pair<K, V>  _kv;	//该节点的key和value

	int _bf; //balance factor 平衡因子
	AVLTreeNode(const pair<K, V>& kv)	//该节点初始化
		:_left(nullptr)  
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)  
		, _bf(0)
	{}
};

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _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;
			}
		}

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

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				//更新结束
				break;
			}
			else if (parent->_bf == -1 || parent->_bf == 1)
			{
				//继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == -2 || parent->_bf == 2)
			{
				//当前子树出现了问题，需要旋转平衡一下
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					//右单旋
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					//左单旋
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					//左右双旋
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					//右左双旋
					RotateRL(parent);
				}
				break;
			}
			else
			{
				//理论上不会出现这种情况，但仍要判断，大佬都不能保证自己的代码没有bug
				assert(false);
			}

		}
		return true;
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		parent->_left = subLR;
		if (subLR)	//subLR有可能为空，不为空时才能调整subLR的父节点
			subLR->_parent = parent;
		subL->_right = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		subL->_bf = parent->_bf = 0;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		parent->_right = subRL;
		if (subRL)	//subRL有可能为空，不为空时才能调整subRL的父节点
			subRL->_parent = parent;
		subR->_left = parent;
		//parent不一定就是根节点，也可能是子树，所以要设置一个ppNode来标记parent的父节点
		Node* ppNode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		subR->_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)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			subL->_bf = 0;
			subLR->_bf = 0;
			parent->_bf = 1;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			subLR->_bf = 0;
			parent->_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;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			//理论上不会出现的情况
			assert(false);
		}
	}
	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 << endl;
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	int Height()
	{
		return _Height(_root);
	}

	int Size()
	{
		return _Size(_root);
	}
private:
	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		return max(_Height(root->_left), _Height(root->_right)) + 1;
	}
	bool _IsBalance(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		//不平衡
		if (abs(leftHeight - rightHeight) >= 2)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		//顺便检查一下平衡因子是否正确
		if (rightHeight - leftHeight != root->_bf)
		{
			cout << root->_kv.first << endl;
			return false;
		}

		return _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

void TestAVLTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert({ e,e });
	}

	t1.InOrder();
}
void TestAVLTree2()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	AVLTree<int, int> t1;
	for (auto e : a)
	{
		t1.Insert({ e,e });
	}
	t1.InOrder();
	cout << t1.IsBalance() << endl;
}

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

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

相关文章

【C++】类与对象——多态详解

【C++】类与对象——多态详解

目录 一、多态的定义 二、重载、覆盖(重写)、隐藏(重定义)的对比 三、析构函数重写 四、C11 override 和 final 1. final 2. override 五、抽象类 六、多态的原理 一、多态的定义 多态是在不同继承关系的类对象&#xff0c;去调用同一函数&#xff0c;产生了不同的行为…
阅读更多...
【机器学习】机器学习与大型预训练模型的前沿探索：跨模态理解与生成的新纪元

【机器学习】机器学习与大型预训练模型的前沿探索：跨模态理解与生成的新纪元

&#x1f512;文章目录&#xff1a; &#x1f4a5;1.引言 ☔2.跨模态理解与生成技术概述 &#x1f6b2;3.大型预训练模型在跨模态理解与生成中的应用 &#x1f6f4;4.前沿探索与挑战并存 &#x1f44a;5.未来趋势与展望 &#x1f4a5;1.引言 近年来&#xff0c;机器学习领…
阅读更多...
使用C/C++ API接口操作 Zookeeper 数据

使用C/C++ API接口操作 Zookeeper 数据

ZooKeeper 支持 Java 和 C 的API接口。本文将介绍使用 C/C 语言客户端库的编译安装和使用入门。 一、编译安装 PS&#xff1a;就在上一篇文章还觉得安装和配置 jdk 、maven 麻烦&#xff0c;所以当时选择 apache-zookeeper-[version]-bin.tar.gz 的版本。然而&#xff0c;本文…
阅读更多...
【C++要哮着学】类和对象

【C++要哮着学】类和对象

文章目录 前言面向过程和面相对象初步认识类的定义类的访问限定符及封装访问限定符封装 类的作用域类的实例化类对象模型如何计算类的大小结构体内存对齐规则类对象的存储方式1.对象中包含类的各个成员2.代码只保存一份&#xff0c;在对象中保存存放代码的地址3.只保存成员变量…
阅读更多...
权限维持--linux

权限维持--linux

隐藏文件/夹&-开头文件 如何创建: 在文件名之前加.即可 touch .1.s 如何清除、查找&#xff1a; ls -al rm -fr -文件 已-开头的文件直接读取是不行的需要带目录 隐藏时间戳 ①用其他文件的时间 touch -r zww.php testq.txt 如何清除、查看&#xff1a; stat test…
阅读更多...
KDE-Ambari-Metrics-Collector问题排查解决手册

KDE-Ambari-Metrics-Collector问题排查解决手册

文档说明 本文档是为了解决KDE平台的Ambari-Metrics-Collector服务在运行时遇到的问题而提供的问题排查和解决方法的参考文档 说明： 当前的Ambari-Metrics-Collector服务包括了ams-collector和ams-hbase两个程序，在Ambari-Metrics-Collector安装的节点执行ps -elf|grep am…
阅读更多...
【算法】前缀和——二维前缀和模板题

【算法】前缀和——二维前缀和模板题

本节博客是通过——二位前缀和模板题来介绍前缀和二维算法&#xff0c;有需要借鉴即可。 目录 1.题目2.暴力求解3.二维前缀和算法3.代码示例4.总结 1.题目 题目链接&#xff1a;LINK 2.暴力求解 这里我们首先想到的就是一个暴力求解的方式&#xff0c;挨个需要的进行遍历就…
阅读更多...
基于SA模拟退火优化算法的TSP问题求解matlab仿真,并对比ACO蚁群优化算法

基于SA模拟退火优化算法的TSP问题求解matlab仿真,并对比ACO蚁群优化算法

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 5.完整程序 1.程序功能描述 基于SA模拟退火优化算法的TSP问题求解matlab仿真,并对比ACO蚁群优化算法,对比两个算法的仿真时间&#xff0c;收敛曲线&#xff0c;以及路径规划的结果&#xff0…
阅读更多...
独享IP是原生IP吗?

独享IP是原生IP吗?

原生IP&#xff1a; 原生IP是指由Internet服务提供商&#xff08;ISP&#xff09;直接分配给用户的IP地址&#xff0c;这些IP地址通常反映了用户的实际地理位置和网络连接。原生IP是用户在其所在地区或国家使用的真实IP地址&#xff0c;与用户的物理位置直接相关。在跨境电商中…
阅读更多...
从零训练yolov8

从零训练yolov8

1.收集数据 2.数据标注 pip install labelimg3.划分数据集 0.2的验证机0.8的训练集 import os from shutil import copyfile from sys import exit import randomsource r"D:\Data\imgs\screenc" \\ target_train r"D:\Data\imgs\datasets\mydata\images\t…
阅读更多...
访存优化实践之一 : CPU、GPU、DDR与访存路径介绍

访存优化实践之一 : CPU、GPU、DDR与访存路径介绍

一、CPU的访存路径 上图是目前主流的CPU架构介绍。可以看到，CPU的访存路径：先经过MMU，然后经过Cache，最后到达DRAM。这其中涉及到的关键内容为基于MMU的内存管理以及缓存机制。 1.1、基于MMU的内存管理 众所周知，在计算机设计之处是没有虚拟地址的概念的，CPU发出的地址即…
阅读更多...
win中的vscode利用ssh插件，在同一台电脑的virtualbox虚拟出来的ubuntu中编译，调试设置方法

win中的vscode利用ssh插件，在同一台电脑的virtualbox虚拟出来的ubuntu中编译，调试设置方法

vscode中安装ssh插件virtualbox7.0中的设置&#xff1a; 在网络管理器中添加host-only网卡&#xff0c;用来主机和虚拟机双向通信。这个网卡能在win的设备管理器里面看到手动配置网卡&#xff0c;其中ip地址是另一个网段的&#xff0c;主机ip地址是192.168.1.1。这个网卡对于虚…
阅读更多...
ELK 日志监控平台（二）- 优化日志格式

ELK 日志监控平台（二）- 优化日志格式

文章目录 ELK 日志监控平台&#xff08;二&#xff09;- 优化日志格式1.日志输出要点2.优化应用的日志格式2.1.确定日志输出要点来源2.1.1.服务名称2.1.2.服务环境2.1.3.日志级别2.1.4.日志输出时间2.1.5.日志内容2.1.6.日志输出对象2.1.7.线程名称 2.2.logback.xml修改日志输出…
阅读更多...
Java网络编程之TCP协议核心机制(二)

Java网络编程之TCP协议核心机制(二)

目录 题外话 正题 滑动窗口机制 如果出现丢包问题怎么办?? 滑动窗口触发条件 流量控制 拥塞控制 小结 题外话 宿舍没有空调的感觉谁懂?!!! 人要蒸发了,八点自动热醒,直接强行学习 正题 我们继续讲解TCP协议核心机制 上篇博客讲完了,建立连接机制,确认应答机制,超时…
阅读更多...
Boxy SVG for Mac：打造精致矢量图形的得力助手

Boxy SVG for Mac：打造精致矢量图形的得力助手

在矢量图形设计领域&#xff0c;Boxy SVG for Mac以其出色的性能和丰富的功能&#xff0c;成为了设计师们的得力助手。 Boxy SVG for Mac(矢量图编辑器) v4.32.0免激活版下载 Boxy SVG具备强大的编辑能力&#xff0c;支持节点编辑、路径绘制、颜色填充等多种操作&#xff0c;让…
阅读更多...
struct.unpack_from()学习笔记

struct.unpack_from()学习笔记

struct.unpack_from(fmt,b_data,offset) 按照指定的格式fmt&#xff0c;从偏移位置offset&#xff0c;对b_data开始解包&#xff0c;返回数据格式是一个元组(v1,v2…) fmt可以有&#xff1a; _struct.py: The remaining chars indicate types of args and must match exactly;…
阅读更多...
实现 YOLO 目标计数 | 含代码示例

实现 YOLO 目标计数 | 含代码示例

点击下方卡片&#xff0c;关注“小白玩转Python”公众号 在YOLO算法的无数应用中&#xff0c;我们想聚焦于一个真实的场景&#xff1a;道路车辆计数。这个用例对于智能城市的交通规划和决策具有重要意义。在这篇文章中&#xff0c;我们将带您一步步实现YOLO目标检测和计数&…
阅读更多...
工业路由器在新能源数字化中的应用：重塑能源行业的未来

工业路由器在新能源数字化中的应用：重塑能源行业的未来

随着全球对可再生能源和能源效率的追求日益加强&#xff0c;新能源数字化已成为推动行业发展的关键因素。在这一变革的浪潮中&#xff0c;工业路由器以其卓越的性能和独特的功能&#xff0c;成为新能源数字化不可或缺的核心组件。本文将深入探讨工业路由器在新能源数字化中的应…
阅读更多...
对话：用言语构建深刻的思想碰撞

对话：用言语构建深刻的思想碰撞

对话&#xff1a;用言语构建深刻的思想碰撞 在写书中&#xff0c;对话是一种有力的工具&#xff0c;能与读者进行有效的沟通和交流&#xff0c;引发深思和反思。它不仅是信息传递的方式&#xff0c;更是加深情感、探讨主题和吸引读者参与的桥梁。你应从读者的角度思考&#xf…
阅读更多...
【学习AI-相关路程-工具使用-自我学习-jetsoncudapytorch-开发工具尝试-基础样例 （3）】

【学习AI-相关路程-工具使用-自我学习-jetsoncudapytorch-开发工具尝试-基础样例 （3）】

【学习AI-相关路程-工具使用-自我学习-jetson&cuda&pytorch-开发工具-安装尝试-基础样例 &#xff08;3&#xff09;】 1、前言2、环境说明3、自我总结&#xff08;1&#xff09;了解整体过程阶段 1: 硬件设置阶段 2: 软件准备阶段 3: 数据准备阶段 4: 模型设计和训练阶…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023