AVL树介绍与构建

目录

AVL树的概念

二叉树的构建

平衡因子的更新

旋转

左单旋

旋转过程

左单旋代码

右单旋

旋转过程

右单旋代码

左右双旋

发生情况

抽象图

具体图

平衡因子更新

左右双旋代码

右左双旋

右左双旋旋代码

验证测试AVL树

测试成员函数

测试代码

AVL树实现代码

AVL树的删除(了解)

AVL树的性能

        在之前对map/multimap/set/multiset进行了简单的介绍，而这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现

AVL树的概念

一个高等平衡的二叉树

        二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年
发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。


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

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

        如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在
O(log n)，搜索时间复杂度O(log n)

二叉树的构建

参考文章：

平衡因子的更新

平衡因子更新规则

1、parent->_bf == 0说明之前parent->_bf 是 1 或者 -1说明之前parent一边高一边低，这次插入填上矮的那一边，parent所在的字数高度不变，不需要继续向上更新


2、parent->_bf == 1 或者 -1 说明之前parent->_bf == 0，两边一样高，现在插入一边更高了，parent所在子树高度变高了，继续往上更新


3、parent->_bf == 2 或者 -2，说明之前 parent->_bf == 1 或者 -1，现在插入严重不平衡，违反规则，就地处理 -- 旋转

旋转

根据AVL树概念可以得到以下的旋转规则

旋转规则:
        1、让这颗子树左右高度差不超过1
        2、旋转过程中继续保持他是搜索树
        3、更新调整孩子节点的平衡因子
        4、让这颗子树的高度跟插入前保持一致

左单旋

抽象图 

旋转过程

        需要注意的是，这里的旋转可能是指的是 子树 或者 整棵树，注意到第四条规则，保持让这颗子树的高度跟插入前保持一致，0的话就不需要继续向上更新，但是还是1或者-1的话就需要继续向上更新平衡因子了，假如又出现2的平衡因子那么就需要继续旋转，直到根节点

左单旋代码

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;	//父节点的右孩子
		Node* subRL = subR->_left;		//父节点的右孩子的左孩子

		parent->_right = subRL;
		if (subRL)						//如果subRL不为空，那么它的父节点更新为parent
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;	//保留父节点的父节点(因为这可能是一个子树)
		subR->_left = parent;			//更新subR的左孩子
		parent->_parent = subR;			//把之前的父节点更新为subR的左孩子

		if (ppNode == nullptr)	//假如ppNode为空，说明这是正棵树
		{
			_root = subR;				//更新root节点
			_root->_parent = nullptr;	//把它的父节点置为空
		}
		else      //否则就判断它是左还是右节点，再更新该旋转子树的父节点
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode; //新该旋转子树的父节点
		}

		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;

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

		//if (_root == parent); 这种写法也是一个道理
		if (ppNode == nullptr)
		{
			_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;
	}

左右双旋

发生情况

抽象图

具体图

平衡因子更新

这里是b插入，c插入大同小异

左右双旋代码

	//左右双旋
	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;	//记录父亲的左子树
		Node* subLR = subL->_right;//记录父亲的左子树的右子树
		int bf = subLR->_bf;	//记录subLR节点的平衡因子，便以判断插入在b(左子树)还是c(右子树)

		//先左旋转，再右旋转
		RotateL(parent->_left);
		RotateR(parent);

		//判断插入情况并更新平衡因子
		if (bf == -1)		//subLR左子树新增
		{
			subL->_bf = 0;	//这里的平衡因子在上面旋转的时候就已经更新了，但是为了不耦合单旋代码，特地在这里再进行一次更新
			parent->_bf = 1;//这里实际更新的(如果单旋正常工作)
			subLR->_bf = 0;	//正常更新平衡因子一定会为0
		}
		else if (bf == 1)	//subLR右子树新增
		{
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)	//subLR自己就是新增的节点，单折线型
		{
			subL->_bf = 0;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else
		{
			assert(false);	//程序出错
		}
	}

右左双旋

实际操作和左右双旋大致一样，这里是c插入

 

右左双旋旋代码

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

		//先右旋转，再左旋转
		RotateR(parent->_right);
		RotateL(parent);

		//判断插入情况并更新平衡因子
		if (bf == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

验证测试AVL树

测试成员函数

int Height(Node* root)	//递归遍历高度
	{
		if (root == nullptr)
			return 0;

		int lh = Height(root->_left);
		int rh = Height(root->_right);

		return lh > rh ? lh + 1 : rh + 1;
	}

	bool IsBalance()	//便以外面调用
	{
		return _IsBalance(_root);
	}

	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);
	}

测试代码

void TestAVLTree1()	//测试代码
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}
	
	t.Inorder();

	cout << t.IsBalance() << endl;
}

void TestAVLTree2()	//测试代码,随机数的检查
{
	srand((unsigned int)time(NULL));
	const size_t N = 10000;
	AVLTree<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand();
		t.Insert(make_pair(x, x));
		//cout << t.IsBalance() << endl;
	}

	t.Inorder();

	cout << t.IsBalance() << endl;
}

旋转总结：
假如以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为根的子树个高度降低，已经平衡，不需要再向上更新

AVL树实现代码

#pragma once
#include<iostream>
#include<assert.h>
#include<time.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>
struct 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)	//左边新增，--
			{
				parent->_bf--;
			}
			else                      //右边新增，++
			{
				parent->_bf++;
			}

			//1、parent->_bf == 0说明之前parent->_bf 是 1 或者 -1
			//说明之前parent一边高一边低，这次插入填上矮的那一边，parent所在的字数高度不变，不需要继续向上更新
			//2、parent->_bf == 1 或者 -1 说明之前parent->_bf == 0，两边一样高，现在插入一边更高了
			//parent所在子树高度变高了，继续往上更新
			//3、parent->_bf == 2 或者 -2，说明之前 parent->_bf == 1 或者 -1，现在插入严重不平衡，违反规则
			//就地处理 -- 旋转

			//旋转:
			//1、让这颗子树左右高度差不超过1
			//2、旋转过程中继续保持他是搜索树
			//3、更新调整孩子节点的平衡因子
			//4、让这颗子树的高度跟插入前保持一致
			if (parent->_bf == 0)	//当平衡因子为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)
				{
					RotateLR(parent);
				}
				//右左双旋
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}

				break;
			}
			else
			{
				assert(false); //再有情况就直接断死，已经坏掉了(代码出错)
			}
		}

		return true;	//插入成功
	}

	//左单旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;	//父节点的右孩子
		Node* subRL = subR->_left;		//父节点的右孩子的左孩子

		parent->_right = subRL;
		if (subRL)						//如果subRL不为空，那么它的父节点更新为parent
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;	//保留父节点的父节点(因为这可能是一个子树)
		subR->_left = parent;			//更新subR的左孩子
		parent->_parent = subR;			//把之前的父节点更新为subR的左孩子

		if (ppNode == nullptr)	//假如ppNode为空，说明这是正棵树
		{
			_root = subR;				//更新root节点
			_root->_parent = nullptr;	//把它的父节点置为空
		}
		else      //否则就判断它是左还是右节点，再更新该旋转子树的父节点
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode; //新该旋转子树的父节点
		}

		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;

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

		//if (_root == parent); 这种写法也是一个道理
		if (ppNode == nullptr)
		{
			_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 RotateLR(Node* parent)
	{
		Node* subL = parent->_left;	//记录父亲的左子树
		Node* subLR = subL->_right;//记录父亲的左子树的右子树
		int bf = subLR->_bf;	//记录subLR节点的平衡因子，便以判断插入在b(左子树)还是c(右子树)

		//先左旋转，再右旋转
		RotateL(parent->_left);
		RotateR(parent);

		//判断插入情况并更新平衡因子
		if (bf == -1)		//subLR左子树新增
		{
			subL->_bf = 0;	//这里的平衡因子在上面旋转的时候就已经更新了，但是为了不耦合单旋代码，特地在这里再进行一次更新
			parent->_bf = 1;//这里实际更新的(如果单旋正常工作)
			subLR->_bf = 0;	//正常更新平衡因子一定会为0
		}
		else if (bf == 1)	//subLR右子树新增
		{
			subL->_bf = -1;
			parent->_bf = 0;
			subLR->_bf = 0;
		}
		else if (bf == 0)	//subLR自己就是新增的节点，单折线型
		{
			subL->_bf = 0;
			parent->_bf = 0;
			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 == -1)
		{
			subR->_bf = 1;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == 0)
		{
			subR->_bf = 0;
			parent->_bf = 0;
			subRL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void Inorder()	//让外部调用内部的中序，因为外部不好传根节点，我们在内部调用可以解决这一点
	{
		_Inorder(_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 lh = Height(root->_left);
		int rh = Height(root->_right);

		return lh > rh ? lh + 1 : rh + 1;
	}

	bool IsBalance()	//便以外面调用
	{
		return _IsBalance(_root);
	}

	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;
};

void TestAVLTree1()	//测试代码
{
	//int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}
	
	t.Inorder();

	cout << t.IsBalance() << endl;
}

void TestAVLTree2()	//测试代码,随机数的检查
{
	srand((unsigned int)time(NULL));
	const size_t N = 10000;
	AVLTree<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand();
		t.Insert(make_pair(x, x));
		//cout << t.IsBalance() << endl;
	}

	t.Inorder();

	cout << t.IsBalance() << endl;
}

AVL树的删除(了解)
 

        因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置，具体实现就不是AVL树的强项了，有兴趣可以自行学习

AVL树的性能


        AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即log_2 (N)。

        但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。

        因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

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

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

相关文章

使用virtualenv导入ssl模块找不到指定的模块

使用virtualenv导入ssl模块找不到指定的模块

最近在学习tensorflow&#xff0c;由于教程里面使用的是virtualenv&#xff0c;所以就按照教程开始安装了虚拟环境。但是在使用的时候&#xff0c;卡在了import ssl这一步&#xff0c;提示如下错误 >>> import ssl Traceback (most recent call last):File "<…
阅读更多...
兼容Lodash的真正替代者

兼容Lodash的真正替代者

大家好&#xff0c;我是农村程序员&#xff0c;独立开发者&#xff0c;前端之虎陈随易。 这是我的个人网站&#xff1a;https://chensuiyi.me&#xff0c;欢迎一起交朋友~ 今天给大家分享一个前端工具库 Lodash 的替代品 es-toolkit。 仓库地址&#xff1a;https://github.com…
阅读更多...
Android 自定义 Dialog 实现列表 单选，多选，搜索

Android 自定义 Dialog 实现列表 单选，多选，搜索

前言 在Android开发中&#xff0c;通过对话框让用户选择&#xff0c;筛选信息是很方便也很常见的操作。本文详细介绍了如何使用自定义 Dialog、RecyclerView 以及自定义搜索框 来实现选中状态和用户交互&#xff0c;文中大本分代码都有明确注释&#xff0c;主打一个简单明了&a…
阅读更多...
A survey of loss functions for semantic segmentation——论文笔记

A survey of loss functions for semantic segmentation——论文笔记

摘要 图像分割一直是一个活跃的研究领域&#xff0c;因为它有着广泛的应用范围&#xff0c;从自动疾病检测到自动驾驶汽车。过去五年中&#xff0c;各种论文提出了用于不同场景&#xff08;如数据偏斜、稀疏分割等&#xff09;的目标损失函数。在本文中&#xff0c;我们总结了…
阅读更多...
NVR监测软件/设备EasyNVR多个NVR同时管理构建智慧城市的大数据解决方案

NVR监测软件/设备EasyNVR多个NVR同时管理构建智慧城市的大数据解决方案

在当今的数字化时代&#xff0c;安防视频监控已成为各行各业不可或缺的一部分&#xff0c;无论是在智慧工地、智慧工厂、智慧景区还是智慧水利等领域&#xff0c;都需要高效、可靠的监控系统来保障安全。 一、背景需求分析 随着科技的发展&#xff0c;智慧城市建设成为城市发展…
阅读更多...
★ 算法OJ题 ★ 前缀和算法（上）

★ 算法OJ题 ★ 前缀和算法（上）

Ciallo&#xff5e;(∠・ω< )⌒☆ ~ 今天&#xff0c;将和大家一起做几道前缀和算法题 ~ ❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️❄️ 澄岚主页&#xff1a;椎名澄嵐-CSDN博客 算法专栏&#xff1a;★ 优选算法100天 ★_椎名澄嵐的博客-CSDN博客 ❄️❄️❄…
阅读更多...
毕业设计选题：基于Django+Vue的物资配送管理系统的设计与实现

毕业设计选题：基于Django+Vue的物资配送管理系统的设计与实现

开发语言&#xff1a;Python框架&#xff1a;djangoPython版本&#xff1a;python3.7.7数据库&#xff1a;mysql 5.7数据库工具&#xff1a;Navicat11开发软件&#xff1a;PyCharm 系统展示 管理员登录界面 管理员功能界面 申领者管理 后勤处管理 物资信息管理 入库信息管理 …
阅读更多...
i春秋web题库——题目名称：SQLi

i春秋web题库——题目名称：SQLi

WEB——SQLi 写在之前&#xff1a;题目简介&#xff1a;题目分析&#xff1a; 写在之前&#xff1a; 本题在CSDN上或是其它博客上有过解答&#xff0c;只不过不知是什么原因&#xff0c;我没有找到解题过程比较完整的文章。于是我决定在CTF初学阶段写一篇这样的博客&#xff0…
阅读更多...
ctfshow(78-＞81)--文件包含漏洞

ctfshow(78-＞81)--文件包含漏洞

Web78 源代码如下&#xff1a; if(isset($_GET[file])){$file $_GET[file];include($file); }else{highlight_file(__FILE__);代码审计&#xff1a; 使用 include() 进行文件包含&#xff0c;通过GET方法 传递参数file 获取被包含的文件。 思路&#xff1a; 利用 data://…
阅读更多...
已解决：Uncaught SyntaxError: Unexpected token ＜

已解决：Uncaught SyntaxError: Unexpected token ＜

已解决&#xff1a;Uncaught SyntaxError: Unexpected token < 文章目录 写在前面问题描述报错原因分析 解决思路解决办法1. 使用开发者工具检查网络请求2. 验证脚本路径3. 检查服务器配置4. 处理跨域请求5. 检查打包工具配置6. 确认内容类型7. 使用原始文件进行测试8. 处理…
阅读更多...
基于SpringBoot的电商网站源码（前台+后台）

基于SpringBoot的电商网站源码（前台+后台）

主要功能流程&#xff1a; 前台购物&#xff1a;用户在前台进行商品浏览、选购及下单。个人中心查看&#xff1a;用户登录后可在个人中心查看订单状态、个人信息等。后台发货&#xff1a;管理员在后台系统处理订单&#xff0c;包括发货、退款等操作。 运行环境&#xff1a; …
阅读更多...
iOS 18.2 可让欧盟用户删除App Store、Safari、信息、相机和照片应用

iOS 18.2 可让欧盟用户删除App Store、Safari、信息、相机和照片应用

升级到 iOS 18.2 之后&#xff0c;欧盟的 iPhone 用户可以完全删除一些核心应用程序&#xff0c;包括 App Store、Safari、信息、相机和 Photos 。苹果在 8 月份表示&#xff0c;计划对其在欧盟的数字市场法案合规性进行更多修改&#xff0c;其中一项更新包括欧盟用户删除系统应…
阅读更多...
张三进阶之路 | 基于Spring AOP的Log收集

张三进阶之路 | 基于Spring AOP的Log收集

前情提要 &#x1f4cc; 张三对于公司的日志处理系统不满意&#xff0c;认为其性能不佳且功能有限。为了展示自己的能力和技术实力&#xff0c;他决定利用Spring AOP&#xff08;面向切面编程&#xff09;开发一个更高效的日志处理系统&#xff0c;并将其存储在Redis中。 首先…
阅读更多...
初识算法 · 二分查找(4)

初识算法 · 二分查找(4)

目录 前言&#xff1a; 寻找峰值 题目解析 算法原理 算法编写 寻找旋转排序数组中的最小值 题目解析 算法原理 算法编写 寻找缺失的数字 题目解析 算法原理 算法编写 前言&#xff1a; ​本文的主题是二分查找&#xff0c;通过三道题目讲解&#xff0c;一道是寻找…
阅读更多...
超越OpenAI GPT-4o，Yi-Lightning指南：中国AI大模型新巅峰

超越OpenAI GPT-4o，Yi-Lightning指南：中国AI大模型新巅峰

Yi-Lightning 是零一万物公司最新发布的旗舰模型&#xff0c;它在国际权威盲测榜单 LMSYS 上超越了硅谷知名 OpenAI GPT-4o-2024-05-13、Anthropic Claude 3.5 Sonnet&#xff0c;排名世界第六&#xff0c;中国第一&#xff0c;这标志着中国大模型首次实现超越 OpenAI GPT-4o 的…
阅读更多...
InnoDB 存储引擎的底层逻辑架构白话-必知必会

InnoDB 存储引擎的底层逻辑架构白话-必知必会

目录标题 前言白话内存架构1. 自适应哈希索引自适应哈希索引的作用自适应哈希索引的工作原理自适应哈希索引与缓存的区别启用和禁用自适应哈希索引 2. Buffer pool3. Change buffer 下面我们就来详细分析一下&#xff0c;数据修改操作的步骤。4. Log Buffer 磁盘架构1. 系统表空…
阅读更多...
一文了解AOSP是什么？

一文了解AOSP是什么？

一文了解AOSP是什么&#xff1f; AOSP基本信息 基本定义 AOSP是Android Open Source Project的缩写&#xff0c;这是一个由Google维护的完全免费和开放的操作系统开发项目。它是Android系统的核心基础&#xff0c;提供了构建移动操作系统所需的基本组件。 主要特点 完全开源…
阅读更多...
echarts散点图

echarts散点图

一、类似散点图折线图不展示折线 option {grid: {left: 10,right: 20,top: 35,bottom: 15,containLabel: true},tooltip: {show: true,trigger: item,backgroundColor: "rgba(0,0,0,0)", // 提示框浮层的背景颜色。formatter: function (params) {var html <d…
阅读更多...
基于Python的B站视频数据分析与可视化

基于Python的B站视频数据分析与可视化

基于Python的B站视频数据分析与可视化 爬取视频、UP主信息、视频评论 功能列表 关键词搜索指定帖子ID爬取指定UP主的主页爬取支持评论爬取生成评论词云图支持数据存在数据库支持可视化 部分效果演示 关键词搜索爬取 指定UP主的主页爬取 指定为黑马的了 爬取视频的时爬取评论…
阅读更多...
基于大模型的Milvus向量数据库的背景与实战应用，计算与索引机制，Python代码实现

基于大模型的Milvus向量数据库的背景与实战应用，计算与索引机制，Python代码实现

大家好&#xff0c;我是微学AI&#xff0c;今天给大家介绍一下基于大模型的Milvus向量数据库的背景与实战应用&#xff0c;计算与索引机制&#xff0c;Python代码实现。本文详细介绍了milvus向量数据库的原理&#xff0c;并通过具体的数据样例和完整的Python代码实现&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023