【数据结构】—AVL树（C++实现）

news2025/1/13 7:51:38

                                                      🎬慕斯主页：修仙—别有洞天

                                                 💜本文前置知识： 搜索二叉树

                                                      ♈️今日夜电波：Letter Song—ヲタみん

                                                                1:36━━━━━━️💟──────── 5:35
                                                                    🔄   ◀️   ⏸   ▶️    ☰  

                                      💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍

目录

一、前言          

        AVL树的概念

        AVL树同二叉搜索树的异同 

二、AVL树的实现

         节点的定义

         AVL树的初始化定义

         AVL树的插入（重点及难点！！！） 

         插入大致步骤

        根据规则找节点

         插入并且链接节点

         向上更新bf（平衡因子）的值

        左单旋

        右单旋

        左右双旋 

        右左双旋 

判断是否符合AVL树

三、整体代码 

一、前言          

        本文是基于二叉搜索树的知识前提下对于AVL树进行叙述的，主要叙述的方面在于AVL树的插入方面，因为AVL树同二叉搜索树的最大区别就在于插入的操作和删除操作，删除操作也是类似的，但是难就难在更新平衡因子，后续会补上。而对于其他的操作如：二叉搜索树的查找操作等等都是相似的，因此本文主要介绍AVL树的插入操作。

        AVL树的概念

         AVL树是一种自平衡二叉搜索树，它的特点是保证了每个节点的左右子树的高度差不超过1。它在插入和删除时会自动平衡，以保持树的高度始终在log N的范围内，从而保证了查找、插入、删除等操作的高效性。AVL树的名字来源于其发明者G.M.Adelson-Velsky和E.M.Landis的姓氏缩写。以下为一颗AVL树：

        AVL树同二叉搜索树的异同 

AVL树和二叉搜索树有很多相似之处，但也有许多不同之处。以下是它们的主要异同点：

相同点：

  1. 它们都是自平衡二叉搜索树，也就是说，在插入和删除节点后，它们能够保持一定的平衡性，从而保证查询操作的时间复杂度始终保持在O(logn)级别。
  2. 它们都遵循二叉搜索树的基本性质，即左子树中的所有节点都小于根节点，右子树中的所有节点都大于根节点。

不同点：

  1. 在AVL树中，除了左右子树高度差不能超过1之外，每个叶子节点还必须在左右子树的高度之间，而在二叉搜索树中则没有这样的限制。（AVL中通常定义一个bf值（balance factor）用于记录节点左右子树的高度差）
  2. 在AVL树中，任何路径上的节点数差异不能超过1，而在二叉搜索树中则没有这样的要求。
  3. 在插入和删除节点后，AVL树需要进行更多的旋转操作来恢复平衡，而二叉搜索树则不需要这样的步骤。
  4. AVL树更适合于查找操作，因为它通过严格的平衡性保证了查询操作的效率，而二叉搜索树更适合于插入和删除操作，因为它可以通过简单的旋转操作来快速调整树结构。

二、AVL树的实现

         节点的定义

         通过KV模型定义AVL树节点，定义三叉链的结构储存父节点以及左右子树节点的地址，定义了bf（平衡因子）用于记录节点右子树与左子树之差（右-左），通过构造函数初始化列表，特别要将bf置为0，如果不置0后续操作可能会出错（别问作者怎么知道的(〃＞皿＜)）。

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	int _bf; // balance factor

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

         AVL树的初始化定义

// AVL: 二叉搜索树 + 平衡因子的限制
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
    // 在AVL树中插入节点
	bool Insert(const pair<K, V>& kv);
    
    // AVL树的验证
    bool _IsBalance(Node* root)
    {
        return _IsBalance(_root);
    }
    
private:
    // 右单旋
	void RotateR(Node* parent);
    // 左单旋
	void RotateL(Node* parent);
    // 右左双旋
	void RotateRL(Node* parent);
    // 左右双旋
	void RotateLR(Node* parent);
    // 求高度
	int _Height(Node* root );
    // 根据AVL树的概念验证pRoot是否为有效的AVL树
    bool _IsBalance(Node* root);

private:
	Node* _root = nullptr;
};

AVL树的插入（重点及难点！！！） 

         插入大致步骤

AVL树的插入操作可以分为以下几步：

  1. 向AVL树中插入一个新节点，首先找到该节点的位置。这可以通过比较新节点的值与当前节点的值来完成，直到找到一个空位置或者到达一个叶子节点为止。按照大往左，小往右，相等返回false的规则。
  2. 依次向下搜索直到找到相应的位置，就将新节点插入到这个位置，并且更新该节点的父节点和兄弟节点的指针。就将新节点插入到这个位置，然后向上更新节点的bf值。
  3. 插入完成后，需要检查新插入的节点是否破坏了AVL树的平衡性。如果破坏了平衡性，就需要执行一系列旋转操作来修复不平衡状态。具体来说，如果新插入的节点使得某个分支的深度增加了一级，那么可以执行一次相应的旋转操作：左旋、右旋、左右旋、右左旋，最后按要求更新各个节点的bf值。

以上就是AVL树的插入操作步骤。需要注意的是，每次插入操作都需要按照这些步骤来进行，才能保证AVL树的平衡性。

        根据规则找节点

         如果_root为空（即空树）则新建节点并返回。比较节点的值，如果插入节点大则往右子树遍历，小则往左子树遍历，如果与节点值相同则无需插入直接返回。后续找到相应的位置后就可跳出循环进行下一步操作。

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;
	}
}
         插入并且链接节点

         更新节点信息，新插入节点的_parent值，以及父节点链接他在左子树还是右子树的判断，链入AVL树中。

		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
         向上更新bf（平衡因子）的值

在插入之前，parent的平衡因子分为三种情况：-1，0, 1, 分以下两种情况：

        1. 如果cur插入到parent的左侧，只需给parent的平衡因子-1即可。

        2. 如果cur插入到parent的右侧，只需给parent的平衡因子+1即可。

此时：parent的平衡因子可能有三种情况：0，正负1， 正负2

        1. 如果parent的平衡因子为0，说明插入之前parent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功。

        2. 如果parent的平衡因子为正负1，说明插入前parent的平衡因子一定为0，插入后被更新成正负1，此时以parent为根的树的高度增加，需要继续向上更新。

        3. 如果parent的平衡因子为正负2，则parent的平衡因子违反平衡树的性质，需要对其进行旋转处理。

while (parent)
{
	if (cur == parent->_left)//根据在左还是右改变bf值
	{
		parent->_bf--;
	}
	else
	{
		parent->_bf++;
	}

	if (parent->_bf == 0)//bf=0则向上都无需变化
	{
		break;
	}
	else if (parent->_bf == 1 || parent->_bf == -1)//bf变化向上遍历改变bf值
	{
		cur = parent;
		parent = parent->_parent;
	}
	else if (parent->_bf == 2 || parent->_bf == -2)//破坏了bf值需要-1<=bf<=1的区间，需要旋转矫正
	{
		if (parent->_bf == 2 && cur->_bf == 1)//左旋情况
		{
			RotateL(parent);
		}
		else if (parent->_bf == -2 && cur->_bf == -1)//右旋情况
		{
			RotateR(parent);
		}
		else if (parent->_bf == 2 && cur->_bf == -1)//右旋再左旋情况
		{
			RotateRL(parent);
		}
		else if (parent->_bf == -2 && cur->_bf == 1)//左旋再右旋情况
		{
			RotateLR(parent);
		}

		// 1、旋转让这颗子树平衡了
		// 2、旋转降低了这颗子树的高度，恢复到跟插入前一样的高度，所以对上一层没有影响，不用继续更新
		break;
	}
	else
	{
		assert(false);//其它情况的bf值表示这颗avl树本身就有问题
	}
}

         左单旋

        由于我们每次插入都会进行调整操作，对此AVL树在新的节点插入前都是合法的，也就是说bf值只会在-1~1之间波动。 当 parent->_bf == 2 && cur->_bf == 1时，我们需要进行左单旋的操作以确保AVL树的合法性（也就是当父节点的右子树高时需要进行左单旋），以下为对此以下为大致的操作图：

        详细旋转过程： 

        对于左单旋操作，我们需要先记录几个节点，分别如下为parent、subR、subRL，因为我们主要是改变这三个的位置。在旋转完成后我们也通过图清晰可见，parent和subR的bf值都是0。

	void RotateL(Node* parent)//左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		Node* parentParent = parent->_parent;

		parent->_parent = subR;
		if (subRL)//判断节点subRL是否为空，防止出错
			subRL->_parent = parent;

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

			subR->_parent = parentParent;
		}

		parent->_bf = subR->_bf = 0;
	}

        右单旋

        对于右单旋，操作同左单旋相似，也是需要记录三个节点：parent、subL、subLR,只不过此时我们是向右旋转。当 parent->_bf == -2 && cur->_bf == -1时，我们需要进行右单旋的操作以确保AVL树的合法性（也就是当父节点的左子树高时需要进行右单旋）。在旋转完成后我们也通过图清晰可见，parent和subR的bf值都是0。以下为对此以下为大致的操作图：

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

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
		

		subL->_right = parent;
		
		Node* parentParent = parent->_parent;

		parent->_parent = subL;

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

			subL->_parent = parentParent;
		}

		parent->_bf = subL->_bf = 0;
	}

        左右双旋 

         当parent->_bf == -2 && cur->_bf == 1时，也就意味着我们的插入操作在如下的b的位置，插入后的图为第二张图，对此我们仅仅只进行一次旋转是远远不够的，如下第三张图为以30为父节点（即subL）只进行了一次左单旋后所变化的图，如果我们仔细观察可以发现这非常符合需要右单旋的操作，因此，此时我们以90为父节点再进行一次右单旋操作。 当然双旋最重要的其实是bf值的确定，我们需要根据最开始的subLR的bf值来确定。

当bf == 0，则subLR自己就是新增因此
            parent->_bf = subL->_bf = subLR->_bf = 0;

当bf==-1，则subLR的左子树新增
           parent->_bf = 1;subL->_bf = 0;subLR->_bf = 0;

当bf==1，则subLR的右子树新增
           subL->_bf = -1;parent->_bf = 0;subLR->_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)
		{
			// subLR自己就是新增
			parent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == -1)
		{
			// subLR的左子树新增
			parent->_bf = 1;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			// subLR的右子树新增
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

          右左双旋 

        当parent->_bf == 2 && cur->_bf == -1时，我们需要进行右左双旋操作，当然同左右双旋一样，只进行一次旋转肯定是不够的，我们也可以猜到先对subR作为一次父节点进行右单旋，在再对parent进行左单旋。

当然双旋最重要的其实是bf值的确定，我们需要根据最开始的subRL的bf值来确定。

当bf == 0，则subRL自己就是新增
            parent->_bf = subR->_bf = subRL->_bf = 0;

当bf==-1，则subRL的左子树新增
            parent->_bf = 0;subRL->_bf = 0;subR->_bf = 1;

当bf==1，则subRL的右子树新增

            parent->_bf = -1;subRL->_bf = 0;subR->_bf = 0;

 

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

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

		if (bf == 0)
		{
			// subRL自己就是新增
			parent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			// subRL的左子树新增
			parent->_bf = 0;
			subRL->_bf = 0;
			subR->_bf = 1;
		}
		else if (bf == 1)
		{
			// subRL的右子树新增
			parent->_bf = -1;
			subRL->_bf = 0;
			subR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

判断是否符合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 _IsBalance(Node* root)
		{
			if (root == nullptr)
				return true;

			int leftHeight = _Height(root->_left);
			int rightHeight = _Height(root->_right);
			if (rightHeight - leftHeight != root->_bf)
			{
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}

			return abs(rightHeight - leftHeight) < 2
				&& _IsBalance(root->_left)
				&& _IsBalance(root->_right);
		}

三、整体代码 

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

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	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;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent)
		{
			if (cur == parent->_left)//根据在左还是右改变bf值
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)//bf=0则向上都无需变化
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)//bf变化向上遍历改变bf值
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)//破坏了bf值需要-1<=bf<=1的区间，需要旋转矫正
			{
				if (parent->_bf == 2 && cur->_bf == 1)//左旋情况
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == -1)//右旋情况
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)//右旋再左旋情况
				{
					RotateRL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)//左旋再右旋情况
				{
					RotateLR(parent);
				}

				// 1、旋转让这颗子树平衡了
				// 2、旋转降低了这颗子树的高度，恢复到跟插入前一样的高度，所以对上一层没有影响，不用继续更新
				break;
			}
			else
			{
				assert(false);//其它情况的bf值表示这颗avl树本身就有问题
			}
		}

		return true;
	}


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

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	private:

		void RotateL(Node* parent)//左旋
		{
			Node* subR = parent->_right;
			Node* subRL = subR->_left;

			parent->_right = subRL;
			subR->_left = parent;

			Node* parentParent = parent->_parent;

			parent->_parent = subR;
			if (subRL)//判断节点subRL是否为空，防止出错
				subRL->_parent = parent;

			if (_root == parent)
			{
				_root = subR;
				subR->_parent = nullptr;
			}
			else
			{
				if (parentParent->_left == parent)//链接subR给父节点的父节点，需要判断是在左子树还是右子树
				{
					parentParent->_left = subR;
				}
				else
				{
					parentParent->_right = subR;
				}

				subR->_parent = parentParent;
			}

			parent->_bf = subR->_bf = 0;
		}


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

			parent->_left = subLR;
			if (subLR)
				subLR->_parent = parent;


			subL->_right = parent;

			Node* parentParent = parent->_parent;

			parent->_parent = subL;

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

				subL->_parent = parentParent;
			}

			parent->_bf = subL->_bf = 0;
		}

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

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

			if (bf == 0)
			{
				// subRL自己就是新增
				parent->_bf = subR->_bf = subRL->_bf = 0;
			}
			else if (bf == -1)
			{
				// subRL的左子树新增
				parent->_bf = 0;
				subRL->_bf = 0;
				subR->_bf = 1;
			}
			else if (bf == 1)
			{
				// subRL的右子树新增
				parent->_bf = -1;
				subRL->_bf = 0;
				subR->_bf = 0;
			}
			else
			{
				assert(false);
			}
		}

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

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

			if (bf == 0)
			{
				// subLR自己就是新增
				parent->_bf = subL->_bf = subLR->_bf = 0;
			}
			else if (bf == -1)
			{
				// subLR的左子树新增
				parent->_bf = 1;
				subL->_bf = 0;
				subLR->_bf = 0;
			}
			else if (bf == 1)
			{
				// subLR的右子树新增
				subL->_bf = -1;
				parent->_bf = 0;
				subLR->_bf = 0;
			}
			else
			{
				assert(false);
			}
		}

		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;

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

			return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
		}

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

			int leftHeight = _Height(root->_left);
			int rightHeight = _Height(root->_right);
			if (rightHeight - leftHeight != root->_bf)
			{
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}

			return abs(rightHeight - leftHeight) < 2
				&& _IsBalance(root->_left)
				&& _IsBalance(root->_right);
		}

	private:
		Node* _root = nullptr;
};

                         感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！ 

                                       

                                                                         给个三连再走嘛~  

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

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

相关文章

TikTok美食狂潮：短视频如何塑造食物文化新趋势

TikTok美食狂潮：短视频如何塑造食物文化新趋势

短视频不仅成为分享美食的平台&#xff0c;更是塑造了一种全新的食物文化趋势。本文将深入探讨TikTok如何通过短视频影响食物文化&#xff0c;并推动美食体验的创新。 创意美食视频的崛起 传统的美食呈现方式通常通过图片或文字&#xff0c;而短视频带来了全新的美食呈现方式。…
阅读更多...
ESP32-Web-Server编程- 使用表格（Table）实时显示设备信息

ESP32-Web-Server编程- 使用表格（Table）实时显示设备信息

ESP32-Web-Server编程- 使用表格&#xff08;Table&#xff09;实时显示设备信息 概述 上节讲述了通过 Server-Sent Events&#xff08;以下简称 SSE&#xff09; 实现在网页实时更新 ESP32 Web 服务器的传感器数据。 本节书接上会&#xff0c;继续使用 SSE 机制在网页实时显…
阅读更多...
（2）(2.2) Lightware SF45/B(350度)

（2）(2.2) Lightware SF45/B(350度)

文章目录 前言 1 安装SF45/B 2 连接自动驾驶仪 3 通过地面站进行配置 4 参数说明 前言 Lightware SF45/B 激光雷达(Lightware SF45/B lidar)是一种小型扫描激光雷达&#xff08;重约 50g&#xff09;&#xff0c;扫描度可达 350 度&#xff0c;扫描范围 50m。 1 安装SF45…
阅读更多...
CRM系统：实现精细化的客户管理，提升客户满意度

CRM系统：实现精细化的客户管理，提升客户满意度

近年来&#xff0c;CRM系统在国内企业的普及度逐渐提高&#xff0c;越来越多的企业选择使用CRM系统来管理客户关系&#xff0c;优化业务流程。那么&#xff0c;CRM系统到底有什么魔力&#xff0c;让众多企业青睐呢&#xff1f;下面我们来说说&#xff0c;为什么建议使用CRM系统…
阅读更多...
同一个公众号下的同一个用户，openid不一致？

同一个公众号下的同一个用户，openid不一致？

背景 公众号授权页面&#xff0c;前端采用的snsapi_userinfo&#xff0c;在用户尚未点击“获取完整性服务”的时候&#xff0c;服务端通过前端的code拿到了一个openid。在用户点击了“获取完整性服务”之后&#xff0c;服务端通过前端的code拿到了另一个openid。同一个用户在同…
阅读更多...
计算机网络之Socket编程

计算机网络之Socket编程

文章目录 前言一、Socket编程二、TCP套接字编程三、UDP套字编程总结 前言 TCP、UDP套接字编程 一、Socket编程 应用进程使用传输层提供的服务才能够交换报文&#xff0c;实现应用协议&#xff0c;实现应用 TCP/IP&#xff1a;应用进程使用Socket API访问传输服务地点&#xff…
阅读更多...
11-30 SpringBoot

11-30 SpringBoot

内嵌的tomcat tomcat的依赖 对于tomcat其实还是一个jar包 spring是一个IOC容器 tomcat的核心对象交给Spring容器 调用核心对象方法 启动Tomcat 1.添加依赖 tomcat-embed-core&#xff0c;叫做tomcat内嵌核心。就是这个东西把tomcat功能引入到了我们的程序中的 排除tomcat&a…
阅读更多...
改造python3中的http.server为简单的文件下载服务

改造python3中的http.server为简单的文件下载服务

改造 修改python3中的http.server.SimpleHTTPRequestHandler&#xff0c;实现简单的文件上传下载服务 simple_http_file_server.py&#xff1a; # !/usr/bin/env python3import datetime import email import html import http.server import io import mimetypes import os …
阅读更多...
游戏反Frida注入检测方案

游戏反Frida注入检测方案

在游戏安全对抗过程中&#xff0c;有不少外挂的实现基于对游戏内存模块进行修改&#xff0c;这类外挂通常会使用内存修改器&#xff0c;除此之外&#xff0c;还有一种门槛相对更高、也更难检测的「注入挂」。 据FairGuard游戏安全数据统计&#xff0c;在游戏面临的众多安全风险…
阅读更多...
uniapp微信小程序实现地图展示控件

uniapp微信小程序实现地图展示控件

最终实现效果&#xff1a; 地图上展示控件&#xff0c;并可以点击。 目录 一、前言 二、在地图上展示控件信息 点击后可进行绘制面图形 1.使用cover-view将控件在地图上展示 2.设置控件样式&#xff0c;使用好看的图标 3.控件绑定点击事件 一、前言 原本使用的是control…
阅读更多...
应用于智慧城管的AI边缘盒子+AI算法一体化解决方案

应用于智慧城管的AI边缘盒子+AI算法一体化解决方案

智慧城管支持十几种城市违规违法场景的识别&#xff0c;覆盖着市容环境、街面秩序、宣传广告、市政设施等类别&#xff0c;能够在很大程度上引导责任单位进行自动整改和自治&#xff0c;积极引导市民加强自我约束、自我教育、自我管理&#xff0c;努力增强市民参与城市管理的责…
阅读更多...
Maya 2024(3D建模、动画和渲染软件)

Maya 2024(3D建模、动画和渲染软件)

Maya 2024是一款非常强大的3D建模、动画和渲染软件&#xff0c;它提供了许多新功能和改进&#xff0c;以帮助建模师、动画师和渲染师更加高效地进行创作。 在建模方面&#xff0c;Maya 2024引入了Symmetry&#xff08;对称&#xff09;功能&#xff0c;可以在网格两侧生成均匀…
阅读更多...
（分类）KNN算法- 参数调优

（分类）KNN算法- 参数调优

在此专栏的上一篇文章的基础上&#xff0c;进行交叉实验获取最佳的K值 上一篇文章&#xff1a;KNN算法案例-鸢尾花分类 数据拆分的过程&#xff1a; 交叉验证&#xff08;Cross Validation&#xff09; 是一种在机器学习中广泛使用的模型评估和参数调优方法。在训练模型时&…
阅读更多...
设计模式精讲：掌握工厂方法与抽象工厂的精髓

设计模式精讲：掌握工厂方法与抽象工厂的精髓

设计模式精讲&#xff1a;掌握工厂方法与抽象工厂的精髓 一、引言&#xff1a;如何学习设计模式&#xff1f;二、工厂方法&#xff08;也叫工厂模式&#xff09;2.1、代码结构2.2、符合的设计原则2.3、小结 三、抽象工厂3.1、代码结构3.2、符合的设计原则3.3、小结 总结 一、引…
阅读更多...
麒麟操作系统根目录权限777修复方法

麒麟操作系统根目录权限777修复方法

在麒麟操作系统中&#xff0c;误操作执行&#xff1a;chmod -R 777 /后&#xff0c;整个根目录权限都变成了777&#xff0c;先找一台相同版本的系统&#xff0c;越干净越好&#xff0c;把该系统的权限导出。 1.在好的机器上执行&#xff1a; #cd / 到根目录 # sudo…
阅读更多...
Docker容器中的OpenCV：轻松构建可移植的计算机视觉环境

Docker容器中的OpenCV：轻松构建可移植的计算机视觉环境

前言 「作者主页」&#xff1a;雪碧有白泡泡 「个人网站」&#xff1a;雪碧的个人网站 构建可移植的计算机视觉环境 文章目录 前言引言简介&#xff1a;目的和重要性&#xff1a; 深入理解Docker和OpenCVDocker的基本概念和优势&#xff1a;OpenCV简介和应用领域&#xff1a;…
阅读更多...
四、虚拟机网络配置

四、虚拟机网络配置

目录 1、VMware网卡配置模式 1.1 桥接模式 1.2 NAT模式 1.3 仅主机模式 ​​​​​​​2、编辑虚拟机的网络编辑器 ​​​​​​​3、编辑Window的虚拟网卡 ​​​​​​​4、修改IP地址为静态 4.1 查看网卡名字 4.2 编辑修改网卡IP地址的配置文件 4.3 重启网络: 4.…
阅读更多...
【Docker】Swarm的overlay网络

【Docker】Swarm的overlay网络

对于理解swarm的网络来讲&#xff0c;个人认为最重要的两个点&#xff1a; 第一是外部如何访问部署运行在swarm集群内的服务&#xff0c;可以称之为入方向流量&#xff0c;在swarm里我们通过ingress来解决。 第二是部署在swarm集群里的服务&#xff0c;如何对外进行访问&…
阅读更多...
探索Playwright的现代自动化测试力量

探索Playwright的现代自动化测试力量

在当今数字化时代&#xff0c;Web应用程序的质量和稳定性对于企业的成功至关重要。为了确保Web应用程序的无缝运行&#xff0c;自动化测试工具成为了开发人员和测试团队的重要工具。多年来&#xff0c;Selenium一直是自动化测试的黄金标准&#xff0c;然而&#xff0c;在不久前…
阅读更多...
从0开始学习JavaScript--JavaScript CommonJS 和 Node.js 模块系统

从0开始学习JavaScript--JavaScript CommonJS 和 Node.js 模块系统

JavaScript 的模块系统是实现模块化开发的关键&#xff0c;而 CommonJS 规范及其在 Node.js 中的应用是其中最为突出的例子。本文将深入研究 JavaScript 中的 CommonJS 模块规范&#xff0c;解析其核心概念&#xff0c;并通过丰富的示例代码展示其在 Node.js 中的实际应用。 C…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023