AVL——平衡搜索树

✅<1>主页：我的代码爱吃辣
📃<2>知识讲解：数据结构——AVL树
☂️<3>开发环境：Visual Studio 2022
💬<4>前言：AVL树是对二叉搜索树的严格高度控制，所以AVL树的搜索效率很高，但是这是需要付出很大的代价的，要维护父亲指针，和平衡因子。

目录

一.AVL的概念

二. AVL树节点及整体结构的定义

 三. AVL树的插入

1. 先按照二叉搜索树的规则将节点插入到AVL树中

2.根据插入的位置调整平衡因子

四.AVL树的旋转

1.左单旋

2.右单旋

3.左右双旋

4.右左双旋

5.总结：

五.AVL树的删除(了解)

六.AVL树的性能

七.完整代码及测试

一.AVL的概念

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

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

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

 

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

二. AVL树节点及整体结构的定义

//AVL树结点
template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(pair<K,V> kv)
		:_kv(kv),
		_bf(0),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr)
	{}
	   
	pair<K, V> _kv;              //Key/Value数据
	int _bf;                     //平衡因子
	AVLTreeNode<K, V>* _left;    //结点的左子树
	AVLTreeNode<K, V>* _right;   //结点的右子树
	AVLTreeNode<K, V>* _parent;  //结点的双亲
};

//AVL树定义
template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool insert(pair<K,V> kv){}
private:
	Node* _root = nullptr;
};

 三. AVL树的插入

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

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

插入过程：

1. 先按照二叉搜索树的规则将节点插入到AVL树中

    bool insert(pair<K,V> kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* cur = _root;//记录当前结点
		Node* parent = nullptr;//记录父亲结点
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		//找到了合适的位置，创建新节点，出入位置
		 cur = new Node(kv);
		//修改新节点的指向
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
          
        //未完待续....
    }

2.根据插入的位置调整平衡因子

平衡因子：右子树高度减去左子树高度。

cur 插入后，parent 的平衡因子一定需要调整，在插入之前，pParent 的平衡因子分为三种情况：-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)
		{
            //cur插入到parent的左侧
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else//cur插入到parent的右侧
			{
				parent->_bf++;
			}

            //需向上调整平衡因子
			if (parent->_bf == 1||parent->_bf==-1)
			{
				cur = parent;
				parent = cur->_parent;
			}
            //无需向上调整平衡因子
			else if(parent->_bf==0)
			{
				break;
			}
            //无需向上调整平衡因子，直接旋转处理
			else if (parent->_bf == 2||parent->_bf==-2)
			{
				//旋转,旋转之后平衡因子已经平衡，可以直接推出
				
				break;
			}
			else//出现的其他的错误情况
			{
				assert(0);
			}
		}

四.AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，
使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

1.左单旋

新节点插入较高右子树的右侧

上图在插入前，AVL树是平衡的，新节点插入到60的右子树中，30右子树增加了一层，导致以60为根的二叉树不平衡，要让30平衡，只能将30右子树的高度减少一层，左子树增加一层，即将右子树往上提，这样30转下来，因为30比60小，只能将其放在60的左子树，而如果60有左子树，左子树根的值一定大于30，小于60，只能将其放在30的右子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：

  • 60节点的左孩子可能存在，也可能不存在。
  • 30可能是整棵树根节点，也可能是子树根节点。

  如果是整棵树根节点，旋转完成后，要更整棵树新根节点；如果是子树根节点，可能是某个节点的左子树，也可能是右子树。

    void RotateL(Node* parent)
	{
		//  a
		//     b
		//        c
		//找到需要旋转的结点
		Node* curR = parent->_right;
		Node* curRL = curR->_left;

		//调整结点，并且修改其父亲结点指针
		parent->_right = curRL;
		if (curRL)//可能为空
		{
			curRL->_parent = parent;
		}
		//在修改子树根节点之前，保存子树根节点的父亲
		Node* pparent = parent->_parent;
		//修改子树根节点
		curR->_left = parent;
		parent->_parent = curR;

		//子树根节点有可能是整棵树的根节点
		if (pparent == nullptr)
		{
			_root = curR;
			_root->_parent = nullptr;
		}
		else//子树根节点不是整棵树的根节点
		{
			//还要看子树是它父亲的左孩子还是右孩子
			if (pparent->_left == parent)
			{
				pparent->_left = curR;
			}
			else
			{
				pparent->_right = curR;
			}
		}
		//修改平衡因子
		curR->_bf = parent->_bf = 0;
	}

2.右单旋

新节点插入较高左子树的左侧

 右单旋过程和左单旋转过程一模一样仅仅只是反过来。

    void RotateR(Node* parent)
	{
		Node* curL = parent->_left;
		Node* curLR = curL->_right;

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

		Node* pparent = parent->_parent;

		curL->_right = parent;
		parent->_parent = curL;

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

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

3.左右双旋

新节点插入较高左子树的右侧---左右：先左单旋再右单旋

 将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再
考虑平衡因子的更新。

注意：旋转之前，60的平衡因子可能是 -1 / 0 / 1，旋转完成之后，根据情况对其他节点的平衡因子进行调整。

 当h=0,时60自己就是一个新插入的结点，此时他的平衡因子就是。

所以旋转之前，需要保存curLR的平衡因子，旋转完成之后，需要根据该平衡因子来调整其他节
点的平衡因子。

4.右左双旋

右左双旋和左右双旋过程一模一样，仅仅只是反过来。

void RotateRL(Node* parent)
	{
		Node* curR = parent->_left;
		Node* curRL = curR->_right;
		int curRL_bf = curRL->_bf;

		RotateL(curR);
		RotateR(parent);

		if (curRL_bf == -1)
		{
			parent->_bf = 0;
			curRL->_bf = 0;
			curR->_bf = 1;
		}
		else if (curRL_bf == 1)
		{
			parent->_bf = -1;
			curRL->_bf = 0;
			curR->_bf = 1;
		}
		else if (curRL_bf == 0)
		{
			parent->_bf = 0;
			curRL->_bf = 0;
			curR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

5.总结：

假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑
1. parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为curR

  • 当curR的平衡因子为1时，执行左单旋
  • 当curR的平衡因子为-1时，执行右左双旋

2. parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为curL

  • 当curL的平衡因子为-1是，执行右单旋
  • 当curL的平衡因子为1时，执行左右双旋

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

        //调整平衡因子
		while (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 1||parent->_bf==-1)//需向上调整平衡因子
			{
				cur = parent;
				parent = cur->_parent;
			}
			else if(parent->_bf==0)//无需向上调整平衡因子
			{
				break;
			}
			else if (parent->_bf == 2||parent->_bf==-2)//无需向上调整平衡因子，直接旋转
			{
				
				if (parent->_bf == 2 && parent->_right->_bf == 1)
				{
					RotateL(parent);//左单旋
				}
				else if (parent->_bf == -2 && parent->_left->_bf == -1)
				{
					RotateR(parent);//右单旋
				}
				else if (parent->_bf == 2 && parent->_left->_bf == -1)
				{
					RotateRL(parent);//右左双旋
				}
				else if (parent->_bf == -2 && parent->_left ->_bf== 1)
				{
					RotateLR(parent);//左右双旋
				}
				else
				{
					assert(false);//其他错误情况
				}
				break;
			}
			else
			{
				assert(0);
			}

五.AVL树的删除(了解)

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不
错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。
具体实现学生们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

六.AVL树的性能

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

七.完整代码及测试

AVL.hpp

#pragma once
#include<iostream>
#include<cassert>
using namespace std;

template<class K, class V>
struct AVLTreeNode
{
	AVLTreeNode(pair<K,V> kv)
		:_kv(kv),
		_bf(0),
		_left(nullptr),
		_right(nullptr),
		_parent(nullptr)
	{
	}
	   
	pair<K, V> _kv;              //Key/Value数据
	int _bf;                     //平衡因子
	AVLTreeNode<K, V>* _left;    //结点的左子树
	AVLTreeNode<K, V>* _right;   //结点的右子树
	AVLTreeNode<K, V>* _parent;  //结点的双亲
};


template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool insert(pair<K,V> kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}

		//找到了合适的位置
		 cur = new Node(kv);
		//
		if (kv.first < parent->_kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;

		//调整平衡因子
		while (parent)
		{
			if (parent->_left == cur)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 1||parent->_bf==-1)//需向上调整平衡因子
			{
				cur = parent;
				parent = cur->_parent;
			}
			else if(parent->_bf==0)//无需向上调整平衡因子
			{
				break;
			}
			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);//左右双旋
				}
				else
				{
					//cout << parent->_bf << ":" << /*parent->_left->_bf << ":" <<*/ parent->_right->_bf << endl;
					assert(false);//其他错误情况
				}
				break;
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

	
	void Inorder()
	{
		_inorder(_root);
		cout << endl;
	}
	


private:
	void _inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_inorder(root->_left);
		cout << root->_kv.first << " ";
		_inorder(root->_right);
	}

	void RotateL(Node* parent)
	{
		//  a
		//     b
		//        c
		//找到需要旋转的结点
		Node* curR = parent->_right;
		Node* curRL = curR->_left;

		//调整结点，并且修改其父亲结点指针
		parent->_right = curRL;
		if (curRL)//可能为空
		{
			curRL->_parent = parent;
		}
		//在修改子树根节点之前，保存子树根节点的父亲
		Node* pparent = parent->_parent;
		//修改子树根节点
		curR->_left = parent;
		parent->_parent = curR;

		//子树根节点有可能是整棵树的根节点
		if (pparent == nullptr)
		{
			_root = curR;
			_root->_parent = nullptr;
		}
		else//子树根节点不是整棵树的根节点
		{
			//还要看子树是它父亲的左孩子还是右孩子
			if (pparent->_left == parent)
			{
				pparent->_left = curR;
			}
			else
			{
				pparent->_right = curR;
			}
			curR->_parent = pparent;
		}
		//修改平衡因子
		curR->_bf = parent->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* curL = parent->_left;
		Node* curLR = curL->_right;

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

		Node* pparent = parent->_parent;

		curL->_right = parent;
		parent->_parent = curL;

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

			}
			curL->_parent = pparent;
		}
		curL->_bf = parent->_bf = 0;
	}

	void RotateLR(Node* parent)
	{
		Node* curL = parent->_left;
		Node* curLR = curL->_right;
		//旋转之前，保存pSubLR的平衡因子，旋转完成之后，
		//需要根据该平衡因子来调整其他节点的平衡因子
		int curLR_bf = curLR->_bf;

		//
		RotateL(curL);
		RotateR(parent);

		if (curLR_bf == -1)
		{
			parent->_bf = 1;
			curLR->_bf = 0;
			curL->_bf = 0;
		}
		else if (curLR_bf == 1)
		{
			parent->_bf = 0;
			curL->_bf = -1;
			curLR->_bf = 0;
		}
		else if (curLR_bf == 0)
		{
			parent->_bf = 0;
			curL->_bf = 0;
			curLR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateRL(Node* parent)
	{
		Node* curR = parent->_right;
		Node* curRL = curR->_left;
		int curRL_bf = curRL->_bf;

		RotateR(curR);
		RotateL(parent);

		if (curRL_bf == -1)
		{
			parent->_bf = 0;
			curRL->_bf = 0;
			curR->_bf = 1;
		}
		else if (curRL_bf == 1)
		{
			parent->_bf = -1;
			curRL->_bf = 0;
			curR->_bf = 0;
		}
		else if (curRL_bf == 0)
		{
			parent->_bf = 0;
			curRL->_bf = 0;
			curR->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	Node* _root = nullptr;
};

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"AVL.hpp"
int main()
{
	int arr1[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int arr2[] = {4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
	AVLTree<int, int> a1;
	AVLTree<int, int> a2;
	for (auto e : arr1)
	{
		a1.insert(make_pair(e,e));
	}
	a1.Inorder();

	for (auto e : arr2)
	{
		a2.insert(make_pair(e, e));
	}
	a2.Inorder();
}

 

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

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

相关文章

数据库索引优化策略与性能提升实践

数据库索引优化策略与性能提升实践

文章目录 什么是数据库索引&#xff1f;为什么需要数据库索引优化&#xff1f;数据库索引优化策略实践案例&#xff1a;索引优化带来的性能提升索引优化规则1. 前导模糊查询不适用索引2. 使用IN优于UNION和OR3. 负向条件查询不适用索引4. 联合索引最左前缀原则5. 范围条件查询右…
阅读更多...
【TS】typescript基础知识

【TS】typescript基础知识

一、类型注解 : number就是类型注解&#xff0c;为变量添加类型约束的方式&#xff0c;约定了什么类型&#xff0c;就只能给变量赋什么类型的值 let age: number 18二、变量命名规则和规范 命名规则&#xff1a;变量名称只能出现数字&#xff0c;字母&#xff0c;下划线(_)…
阅读更多...
python rtsp 硬件解码 二

python rtsp 硬件解码 二

上次使用了python的opencv模块 述说了使用PyNvCodec 模块&#xff0c;这个模块本身并没有rtsp的读写&#xff0c;那么读写rtsp是可以使用很多方法的&#xff0c;我们为了输出到pytorch直接使用AI程序&#xff0c;简化rtsp 输入&#xff0c;可以直接使用ffmpeg的子进程 方法一 …
阅读更多...
DNQ算法原理(Deep Q Network)

DNQ算法原理(Deep Q Network)

1.强化学习概念 学习系统没有像很多其它形式的机器学习方法一样被告知应该做出什么行为 必须在尝试了之后才能发现哪些行为会导致奖励的最大化 当前的行为可能不仅仅会影响即时奖励&#xff0c;还会影响下一步的奖励以及后续的所有奖励 每一个动作(action)都能影响代理将来的…
阅读更多...
手机无人直播软件，有哪些优势？

手机无人直播软件，有哪些优势？

近年来&#xff0c;随着手机直播的流行和直播带货的市场越来越大&#xff0c;手机无人直播软件成为许多商家开播带货的首选。在这个领域里&#xff0c;声音人无人直播系统以其独特的优势&#xff0c;成为市场上备受瞩目的产品。接下来&#xff0c;我们将探讨手机无人直播软件给…
阅读更多...
OpenCV中QR二维码的生成与识别(CIS摄像头解析)

OpenCV中QR二维码的生成与识别(CIS摄像头解析)

1、QR概述 QR(Quick Response)属于二维条码的一种&#xff0c;意思是快速响应的意思。QR码不仅信息容量大、可靠性高、成本低&#xff0c;还可表示汉字及图像等多种文字信息、其保密防伪性强而且使用非常方便。更重要的是QR码这项技术是开源的&#xff0c;在移动支付、电影票、…
阅读更多...
Elasticsearch Split和shrink API

Elasticsearch Split和shrink API

背景&#xff1a; 尝试解决如下问题&#xff1a;单分片存在过多文档&#xff0c;超过lucene限制 分析 1.一般为日志数据或者OLAP数据&#xff0c;直接删除索引重建 2.尝试保留索引&#xff0c;生成新索引 - 数据写入新索引&#xff0c;查询时候包含 old_index,new_index 3.…
阅读更多...
内容分发网络CDN与应用程序交付网络ADN之间的异同

内容分发网络CDN与应用程序交付网络ADN之间的异同

当您想要提高网站性能时&#xff0c;需要考虑许多不同的配置和设施&#xff0c;CDN和ADN是我们常遇见的几种选项之一。“CDN”指“内容分发网络”&#xff0c;而“ADN”指“应用程序交付网络”&#xff0c;但他们两者很容易被混淆&#xff0c;虽然它们的功能和作用都有较大差异…
阅读更多...
使用多个神经网络进行细菌分类（Matlab代码实现）

使用多个神经网络进行细菌分类（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
vellum （Discovering Houdini VellumⅡ柔体系统）学习笔记

vellum （Discovering Houdini VellumⅡ柔体系统）学习笔记

视频地址&#xff1a; https://www.bilibili.com/video/BV1ve411u7nE?p3&spm_id_frompageDriver&vd_source044ee2998086c02fedb124921a28c963&#xff08;搬运&#xff09; 个人笔记如有错误欢迎指正&#xff1b;希望可以节省你的学习时间 ~享受艺术 干杯&#x1f37b…
阅读更多...
[Mac软件]AutoCAD 2024 for Mac(cad2024) v2024.3.61.182中文版支持M1/M2/intel

[Mac软件]AutoCAD 2024 for Mac(cad2024) v2024.3.61.182中文版支持M1/M2/intel

下载地址&#xff1a;前往黑果魏叔官网 AutoCAD是一款计算机辅助设计&#xff08;CAD&#xff09;软件&#xff0c;目前已经成为全球最受欢迎的CAD软件之一。它可以在二维和三维空间中创建精确的技术绘图&#xff0c;并且可以应用于各种行业&#xff0c;如建筑、土木工程、机械…
阅读更多...
【操作系统】24王道考研笔记——第三章 内存管理

【操作系统】24王道考研笔记——第三章 内存管理

第三章 内存管理 一、内存管理概念 1.基本概念 2.覆盖与交换 覆盖技术&#xff1a; 交换技术&#xff1a; 总结&#xff1a; 3.连续分配管理方式 单一连续分配 固定分区分配 动态分区分配 动态分区分配算法&#xff1a; 总结&#xff1a; 4.基本分页存储管理 定义&#xf…
阅读更多...
【Unity3D赛车游戏】【二】如何制作一个真实模拟的汽车

【Unity3D赛车游戏】【二】如何制作一个真实模拟的汽车

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;元宇宙-秩沅 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 秩沅 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a;Uni…
阅读更多...
VoxWeekly｜The Sandbox 生态周报｜20230821

VoxWeekly｜The Sandbox 生态周报｜20230821

欢迎来到由 The Sandbox 发布的《VoxWeekly》。我们会在每周发布&#xff0c;对上一周 The Sandbox 生态系统所发生的事情进行总结。 如果你喜欢我们内容&#xff0c;欢迎与朋友和家人分享。请订阅我们的 Medium 、关注我们的 Twitter&#xff0c;并加入 Discord 社区&#xf…
阅读更多...
01、Cannot resolve MVC View ‘xxxxx前端页面‘

01、Cannot resolve MVC View ‘xxxxx前端页面‘

Cannot resolve MVC View ‘xxxxx前端页面’ 没有找到对应的mvc的前端页面。 代码&#xff1a;前端这里引入了 thymeleaf 模板 解决&#xff1a; 需要添加 thymeleaf 的依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>s…
阅读更多...
基于nginx禁用访问ip

基于nginx禁用访问ip

一、背景 网络安全防护时&#xff0c;禁用部分访问ip,基于nginx可快速简单实现禁用。 二、操作 1、创建 conf.d文件夹 在nginx conf 目录下创建conf.d文件夹 Nginx 扩展配置文件一般在conf.d mkdir conf.d 2、新建blocksip.conf文件 在conf.d目录新建禁用ip的扩展配置文…
阅读更多...
DevExpress WPF HeatMap组件，一个高度可自定义的热图控件！

DevExpress WPF HeatMap组件，一个高度可自定义的热图控件！

像所有DevExpress UI组件一样&#xff0c;HeatMap组件针对速度进行了优化&#xff0c;包括数十个自定义设置和高级API&#xff0c;因此用户可以快速将美观的数据可视化集成到下一个WPF应用程序中。 P.S&#xff1a;DevExpress WPF拥有120个控件和库&#xff0c;将帮助您交付满…
阅读更多...
vscode里配置C#环境并运行.cs文件

vscode里配置C#环境并运行.cs文件

vscode是一款跨平台、轻量级、开源的IDE, 支持C、C、Java、C#、R、Python、Go、Nodejs等多种语言的开发和调试。下面介绍在vscode里配置C#环境。这里以配置.Net SDK v5.0&#xff0c;语言版本为C#9.0&#xff0c;对应的开发平台为VS2019&#xff0c;作为案例说明。 1、下载vsc…
阅读更多...
文件四剑客

文件四剑客

目录 前言 一、正则表达式 二、grep 三、find 四、sed 五、awk 前言 文件四剑客是指在计算机领域中常用的四个命令行工具&#xff0c;包括awk、find、grep和sed。它们在处理文本文件和搜索文件时非常强大和实用。 1. awk是一种强大的文本处理工具&#xff0c;它允许用户根据指…
阅读更多...
数据结构——栈和队列

数据结构——栈和队列

栈和队列的建立 前言一、栈1.栈的概念2.栈的实现3.代码示例&#xff08;1&#xff09;Stack.h&#xff08;2&#xff09;Stack.c&#xff08;3&#xff09;Test.c&#xff08;4&#xff09;运行结果&#xff08;5&#xff09;完整代码演示 二、队列1.队列的概念2.队列的实现3.代…
阅读更多...
最新文章

Copyright @ 2022~2023