【数据结构＆C++】超详细一文带小白轻松全面理解 [ 二叉平衡搜索树-AVL树 ]—— [从零实现＆逐过程分析＆代码演示简练易懂]

前言

大家好吖，欢迎来到 YY 滴C++系列 ，热烈欢迎！ 本章主要内容面向接触过C++的老铁
主要内容含：
在这里插入图片描述

欢迎订阅 YY滴C++专栏！更多干货持续更新！以下是传送门！

目录

  • 一.AVL树的概念
  • 二.AVL树节点的定义(代码演示)
  • 三.AVL树的基本操作：插入
  • 四.AVL树的核心操作：旋转
    • 【1】新节点插入较高右子树的右侧---右右：左单旋
    • 【2】新节点插入较高左子树的左侧—左左：右单旋
    • 【3】新节点插入较高左子树的右侧---左右：先左单旋再右单旋【双旋】
    • 【4】新节点插入较高右子树的左侧---右左：先右单旋再左单旋【双旋】
  • 五.AVL树的验证
      • 1. 验证其为二叉搜索树
      • 2. 验证其为平衡树
  • 六.AVL树的性能＆引入红黑树
  • 七.AVL树的完整代码

一.AVL树的概念

  • 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证 每个结点的左右子树高度之差的绝对值不超过1 (需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
  • 平衡因子是-1，左比右高1；平衡因子是1，右比左高1；平衡因子是0，左右一样高
  • 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
    1. 它的左右子树都是AVL树
    2. 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)
  • 如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在
    O ( l o g 2 n ) O(log_2 n) O(log2​n)，搜索时间复杂度O( l o g 2 n log_2 n log2​n)。

二.AVL树节点的定义(代码演示)

  • 除了基本的左右孩子节点与数据外，还需要引入平衡因子
  • 由于平衡因子取决于左右子树相对高度，所以节点本身 要能够返回父亲节点 ——> 要设置指向父亲节点的指针
  • 注意AVL树节点是三叉链 
template<class T>
struct AVLTreeNode
{
 AVLTreeNode(const T& data)
     : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
 , _data(data), _bf(0)
 {}
 
 AVLTreeNode<T>* _pLeft;   // 该节点的左孩子
 AVLTreeNode<T>* _pRight;  // 该节点的右孩子
 AVLTreeNode<T>* _pParent; // 该节点的父亲节点
 
 T _data;
 int _bf;                  // 该节点的平衡因子
};

三.AVL树的基本操作：插入

  • AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么 AVL树的插入过程可以分为两步：
    1. 按照二叉搜索树的方式插入新节点
    2. 调整节点的平衡因子
  • AVL树的插入过程：
  • 与二叉搜索树同理，二叉搜索树博客传送门：https://blog.csdn.net/YYDsis/article/details/134374001?spm=1001.2014.3001.5501
  • 平衡因子的变化步骤：
  1. 新增在左，parent平衡因子减减
  2. 新增在右，parent平衡因子加加
  3. 平衡因子==0，高度不变，直接break
  4. 平衡因子==1/-1，高度改变-> 会影响祖先 -> 需要继续沿着到根节点root的路径向上更新
  5. 平衡因子==2/-2，高度改变＆ 树不再平衡 ->会影响祖先->需要对parent所在子树进行 旋转 操作，让其平衡 （旋转部分放在part4中详解）
  6. 向上更新，直到根节点（根节点parent==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;
		}

//1. 按照二叉搜索树的方式插入新节点
		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;

//2. 调整节点的平衡因子
		while (parent)//向上更新，直到根节点（根节点parent==0）
		{
			if (cur == parent->_left)// 1.新增在左，parent平衡因子减减
			{
				parent->_bf--;
			}
			else // if (cur == parent->_right)
			{
				parent->_bf++;//2.新增在右，parent平衡因子加加
			}

			if (parent->_bf == 0)//3.平衡因子==0，高度不变，直接break
			{
				// 更新结束
				break;
			}
		      	//4.平衡因子==1/-1，高度改变-> 会影响祖先 -> 需要继续沿着到根节点root的路径向上更新
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 继续往上更新
				cur = parent;
				parent = parent->_parent;
			}
			         //平衡因子==2/-2，高度改变＆ 树不再平衡 ->会影响祖先->
			         //需要对parent所在子树进行 旋转 操作，让其平衡
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 子树不平衡了，需要旋转     （旋转部分为何这么设计放在part4中详解）
				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);
				}

				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

四.AVL树的核心操作：旋转

  • 根据part3中avl树的基本操作"插入"，以下情况会出现旋转
  • 平衡因子==2/-2，高度改变＆ 树不再平衡 ->会影响祖先->需要对parent所在子树进行 旋转 操作，让其平衡 （旋转部分放在part4中详解）
  • 所以一共有四种情况分别如下图所示：
  • 旋转要注意以下三点：
    1. 保持这颗树还是搜索树
    2. 变成平衡树＆降低其高度
    3. 节点是三叉链的形式，旋转后要注意节点链接

【1】新节点插入较高右子树的右侧—右右：左单旋

  • 分析：
  • 如下图所示，新节点插入较高右子树的右侧时候，整体会发生“向左的单旋”

在这里插入图片描述
在这里插入图片描述

  • 核心操作：
  • cur的左给parent的右，parent再成为cur的左
    cur->_right = parent;
    parent->_parent = cur;
  • 注意：节点是三叉链的形式，旋转后要注意节点链接
  • 要设置 祖父节点pparent指向parent，parent的_parent节点指向parent
  • 情况1：特殊情况，父母节点为根节点，空指向cur
  • 情况2：正常情况，祖父节点指向cur
  • 注意：平衡因子变化
  • 观察以上图中变化可知，我们只需要 在最后将cur和parent都调整为0就行：
  • parent->_bf = cur->_bf = 0;
  • 代码展示：
void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;

		Node* ppnode = parent->_parent;//标记出祖父节点

		parent->_parent = cur;


		if (parent == _root)//特殊情况，父母节点为根节点，空指向cur
		{
			_root = cur;
			cur->_parent = nullptr;
		}
		else//正常情况，祖父节点指向cur
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}

			cur->_parent = ppnode;
		}

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

【2】新节点插入较高左子树的左侧—左左：右单旋

  • 相关细节与上面【1】中 “右右：左单旋” 一致，下面展示代码
  • 代码展示：
void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;

		parent->_left = curright;
		if (curright)
		{
			curright->_parent = parent;
		}

		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;

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

			cur->_parent = ppnode;
		}

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

【3】新节点插入较高左子树的右侧—左右：先左单旋再右单旋【双旋】

引入：

  • 我们观察【1】【2】情况，其都是左左/右右，发生逆向的旋转（左左->往右转）（右右->往左转）
  • 而【3】【4】这种双旋的情况呢？如下图所示，观察可以发现，当其是 新节点插入较高左子树的右侧时 ,形成了一个折线
    在这里插入图片描述
  • 进一步观察后，我们发现有 三种情况 会触发双旋,可以观察 curright的平衡因子 判断，分别是：
    1. curright就是新增节点 bf == 0
    2. b处新增节点 bf == -1
    3. c处新增节点 bf == 1在这里插入图片描述
  • 注意：平衡因子变化
  • 我们根据 三种触发双旋的情况 ，对他们平衡因子变化进行分析
  • 1. curright就是新增节点
    parent->_bf = 0;
    cur->_bf = 0;
    curright->_bf = 0;
    在这里插入图片描述
  • 2. b处新增节点
    parent->_bf = 0;
    cur->_bf = -1;
    curright->_bf = 0;
    在这里插入图片描述
    3. c处新增节点
    parent->_bf = 1;
    cur->_bf = 0;
    curright->_bf = 0;
    在这里插入图片描述
void RotateLR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		int bf = curright->_bf;

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

		if (bf == 0)//1. curright就是新增节点 bf == 0
		{
			parent->_bf = 0;
			cur->_bf = 0;
			curright->_bf = 0;
		}
		else if (bf == -1)//2. b处新增节点 bf == -1
		{
			parent->_bf = 1;
			cur->_bf = 0;
			curright->_bf = 0;
		}
		else if (bf == 1)//3. c处新增节点 bf == 1
		{
			parent->_bf = 0;
			cur->_bf = -1;
			curright->_bf = 0;
		}
	}
  • 注意：双旋的本质（表现）
    1. 60的左边给了30的右边
    1. 60的右边给了90的左边
    1. 60成了这棵树的根
      在这里插入图片描述

【4】新节点插入较高右子树的左侧—右左：先右单旋再左单旋【双旋】

  • 相关细节与上面【2】中 “左右：先左单旋再右单旋【双旋】” 一致，下面展示代码
  • 代码展示：
void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		int bf = curleft->_bf;

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

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

五.AVL树的验证

1. 验证其为二叉搜索树

  • 如果其通过 中序遍历 可得到一个 有序 的序列，就说明为其为二叉搜索树

2. 验证其为平衡树

  • 每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
  • 节点的平衡因子是否计算正确
int Height()
	{
		return Height(_root);
	}
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()
	{
		return IsBalance(_root);
	}

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

		int leftHight = Height(root->_left);
		int rightHight = Height(root->_right);

		if (rightHight - leftHight != root->_bf)
		{
			cout << "平衡因子异常:" <<root->_kv.first<<"->"<< root->_bf << endl;
			return false;
		}

		return abs(rightHight - leftHight) < 2
			&& IsBalance(root->_left)
			&& IsBalance(root->_right);
	}

六.AVL树的性能＆引入红黑树

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

  • 红黑树博客传送门：

七.AVL树的完整代码

#pragma once

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

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;  // balance factor

	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:
	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 // if (cur == parent->_right)
			{
				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)
				{
					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);
				}

				break;
			}
			else
			{
				assert(false);
			}
		}


		return true;
	}

	void RotateL(Node* parent)
	{
		++_rotateCount;

		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;

		Node* ppnode = parent->_parent;

		parent->_parent = cur;


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

			}

			cur->_parent = ppnode;
		}

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


	void RotateR(Node* parent)
	{
		++_rotateCount;

		Node* cur = parent->_left;
		Node* curright = cur->_right;

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

		Node* ppnode = parent->_parent;
		cur->_right = parent;
		parent->_parent = cur;

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

			cur->_parent = ppnode;
		}

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

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

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

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

	void RotateLR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curright = cur->_right;
		int bf = curright->_bf;

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

		if (bf == 0)
		{
			parent->_bf = 0;
			cur->_bf = 0;
			curright->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			cur->_bf = 0;
			curright->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			cur->_bf = -1;
			curright->_bf = 0;
		}
	}

	int Height()
	{
		return Height(_root);
	}

	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()
	{
		return IsBalance(_root);
	}

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

		int leftHight = Height(root->_left);
		int rightHight = Height(root->_right);

		if (rightHight - leftHight != root->_bf)
		{
			cout << "平衡因子异常:" <<root->_kv.first<<"->"<< root->_bf << endl;
			return false;
		}

		return abs(rightHight - leftHight) < 2
			&& IsBalance(root->_left)
			&& IsBalance(root->_right);
	}

private:
	Node* _root = nullptr;

public:
	int _rotateCount = 0;
};

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

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

相关文章

Python开源自动化工具Playwright安装及介绍

Python开源自动化工具Playwright安装及介绍

一个非常强大的自动化项目叫 playwright-python 它支持主流的浏览器&#xff0c;包含&#xff1a;Chrome、Firefox、Safari、Microsoft Edge 等&#xff0c;同时支持以无头模式、有头模式运行&#xff0c;并提供了同步、异步的 API&#xff0c;可以结合 Pytest 测试框架 使用&…
阅读更多...
IPO解读丨高处不胜寒，澜沧古茶低头取暖？

IPO解读丨高处不胜寒，澜沧古茶低头取暖？

自A股注册制改革不断深化并全面落地后&#xff0c;不少意欲登陆资本市场的企业转战港股。这个过程中&#xff0c;诞生了很多以“港股”为前缀的“第一股”——“白酒第一股”珍酒李渡、“水果零售第一股”百果园、“智能驾驶第一股”知行汽车、“运动科技第一股”Keep…… 由A…
阅读更多...
STM32与ADXL345加速度计的无线传输与监测应用

STM32与ADXL345加速度计的无线传输与监测应用

ADXL345是一款三轴数字输出加速度计&#xff0c;能够测量出物体在三个方向上的加速度。本文将介绍如何将ADXL345加速度计与STM32微控制器结合使用&#xff0c;通过无线通信技术实现加速度数据的传输与监测。 一、ADXL345与STM32概述 1. ADXL345加速度计 ADXL345是一款低功耗…
阅读更多...
VB.net读写S50/F08IC卡，修改卡片密码控制位源码

VB.net读写S50/F08IC卡，修改卡片密码控制位源码

本示例使用设备&#xff1a;Android Linux RFID读写器NFC发卡器WEB可编程NDEF文本/智能海报/-淘宝网 (taobao.com) 函数声明 Module Module1读卡函数声明Public Declare Function piccreadex Lib "OUR_MIFARE.dll" (ByVal ctrlword As Byte, ByRef serial As Byte, …
阅读更多...
servlet乱码问题

servlet乱码问题

问题&#xff1a;中文乱码 解决&#xff1a;加框的部分
阅读更多...
给折腿的罗技G512键盘换键帽

给折腿的罗技G512键盘换键帽

文章目录 1\. 引言2\. 操作2.1. 用打火机烤2.2. 用钳子拔出来2.2.1. 拔出成功2.2.2. 放大细看2.3. 更换键帽 1. 引言 G512的轴采用的是塑料连接&#xff0c;特别容易腿折在里面&#xff0c;换着的时候&#xff0c;得先把这个卡在里面的塑料腿拿出来才行 放大效果图 2. 操作 可…
阅读更多...
用js切割文字,超出省略

用js切割文字,超出省略

因为项目需要,当人员超过两个事则进行超出省略,如将一个 “张三,李四,王五”,这样的字串切割成"张三,李四…" 效果: 主要用的是基础的切割法 isOutlier(text) {if (!text || text "") return;const parts text.split(","); // 使用逗号将字…
阅读更多...
电力感知边缘计算网关产品设计方案-业务流程设计

电力感知边缘计算网关产品设计方案-业务流程设计

1.工业数据通信流程 工业数据是由仪器仪表、PLC、DCS等工业生产加工设备提供的，通过以太网连接工业边缘计算网关实现实时数据采集。按照现有的通信组网方案，在理想通信状态下可以保证有效获取工业数据的真实性和有效性。 边缘计算数据通信框架图： 2.边缘计算数据处理方案 …
阅读更多...
Zeet构建多云战略充分发挥云的优势

Zeet构建多云战略充分发挥云的优势

大型企业通常拥有基础设施和应用团队&#xff0c;有能力围绕自己的业务需求构建所需平台。但对于技术团队精简、预算紧张的小企业来说&#xff0c;定制平台往往不现实而且难以扩展&#xff0c;是负担不起的“奢侈品”。 这一情况催生了平台即服务&#xff08;PaaS&#xff09;…
阅读更多...
Azure Machine Learning - 什么是 Azure AI 搜索？

Azure Machine Learning - 什么是 Azure AI 搜索？

Azure AI 搜索&#xff08;以前称为“Azure 认知搜索”&#xff09;在传统和对话式搜索应用程序中针对用户拥有的内容提供大规模的安全信息检索。 关注TechLead&#xff0c;分享AI全维度知识。作者拥有10年互联网服务架构、AI产品研发经验、团队管理经验&#xff0c;同济本复旦…
阅读更多...
如何进行手动脱壳

如何进行手动脱壳

脱壳的目的就是找到被隐藏起来的OEP&#xff08;入口点&#xff09; 这里我一共总结了三种方法&#xff0c;都是些自己的理解希望对你们有用 单步跟踪法 一个程序加了壳后&#xff0c;我们需要找到真正的OEP入口点&#xff0c;先运行&#xff0c;找到假的OEP入口点后&#x…
阅读更多...
【2023云栖】大模型驱动DataWorks数据开发治理平台智能化升级

【2023云栖】大模型驱动DataWorks数据开发治理平台智能化升级

随着大模型掀起AI技术革新浪潮&#xff0c;大数据也进入了与AI深度结合的创新时期。2023年云栖大会上&#xff0c;阿里云DataWorks产品负责人田奇铣发布了DataWorks Copilot、DataWorks AI增强分析、DataWorks湖仓融合数据管理等众多新产品能力&#xff0c;让DataWorks这款已经…
阅读更多...
文档明明在桌面上却不显示？5个方法轻松解决！

文档明明在桌面上却不显示？5个方法轻松解决！

“我之前保存文档的时候明明选择保存在桌面&#xff0c;上次看的时候文件还在&#xff0c;但是今天打开电脑后发现我保存在桌面的文档不见了&#xff0c;这是为什么呢&#xff1f;还有机会找回我的文件吗&#xff1f;” 在日常使用电脑时&#xff0c;有些用户为了方便&#xff…
阅读更多...
SAP权限设计简介

SAP权限设计简介

介绍 小技巧 -ERP 权限控制 繁中求简 , 闲聊一下 SAP 复杂权限设计的基本思想。 特别是适合大集团业务的 ERP 系统 , 应该提供一个非常完善的权限控制机制 , 甚至允许将权限控制字段细到字段级别&#xff0c;如果权限控制都做不到这点&#xff0c;估计产品销售就够呛&#x…
阅读更多...
来聊聊阿里1688 /拼多多API接口接入| 让需求回到产品端

来聊聊阿里1688 /拼多多API接口接入| 让需求回到产品端

昨儿办公室讨论起了1688。 对&#xff0c;就是阿里搞批发的那个网站。 在上面&#xff0c;你可以买到各种各样价格低廉的产品&#xff0c;比如&#xff0c;办公用具、女孩子的皮筋、小孩子的玩具等等。 在小批量上&#xff0c;它和拼多多定价类似&#xff0c;但二者的赛道却不同…
阅读更多...
物流实时数仓：采集通道搭建

物流实时数仓：采集通道搭建

系列文章目录 物流实时数仓&#xff1a;环境搭建 文章目录 系列文章目录前言一、环境准备1.前置环境2.hbase安装1.上传并解压2.配置环境变量3.拷贝jar包4.编写配置文件5.分发配置文件 3.Redis安装1.安装需要的编译环境2.上传并解压文件3.编译安装4.后台访问 4.ClickHouse安装5…
阅读更多...
抽象类和接口

抽象类和接口

抽象类和接口 文章目录 抽象类和接口抽象类抽象类概念抽象类语法抽象类特性抽象类的作用 接口接口的概念语法规则接口使用接口特性接口类型是一种引用类型&#xff0c;但是不能直接new接口的对象接口中每一个方法都是public的抽象方法.接口中的方法是不能在接口中实现的&#x…
阅读更多...
（亲测有效）VMware Windows虚拟机扩容

（亲测有效）VMware Windows虚拟机扩容

场景&#xff1a; VMware安装了一个windows系统&#xff0c;现在windows系统剩余空间不足&#xff0c;需要扩容。 解决步骤&#xff1a; 关闭虚拟机&#xff0c;状态如下&#xff1a; 2、点击编辑虚拟机设置-》扩展 3、输入最大磁盘大小-》点击扩展 4、等待成功后&#xff0c…
阅读更多...
Python爬虫实战-批量爬取豆瓣电影排行信息

Python爬虫实战-批量爬取豆瓣电影排行信息

大家好&#xff0c;我是python222小锋老师。 近日锋哥又卷了一波Python实战课程-批量爬取豆瓣电影排行信息&#xff0c;主要是巩固下Python爬虫基础 视频版教程&#xff1a; Python爬虫实战-批量爬取豆瓣电影排行信息 视频教程_哔哩哔哩_bilibiliPython爬虫实战-批量爬取豆瓣…
阅读更多...
光伏拉晶厂RFID智能化生产工序管理

光伏拉晶厂RFID智能化生产工序管理

一、项目背景 随着全球能源短缺和气候变暖的挑战日益突显&#xff0c;清洁能源已成为国内能源发展的主要目标之一&#xff0c;作为清洁能源的重要组成部分&#xff0c;光伏行业在过去几十年中取得了巨大的发展&#xff0c;成为我国的战略性新兴产业之一。在智能制造的大环境下…
阅读更多...
最新文章

Copyright @ 2022~2023