[数据结构]-AVL树

news2025/1/12 13:25:23

前言

作者：小蜗牛向前冲

名言：我可以接受失败，但我不能接受放弃

  如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正

目录

一、AVL树基本知识

1、概念

2、节点定义

3、插入

二、AVL树的旋转

1、右单旋

2、左单旋

 3、左右双旋

4、 右左双旋

三、AVL树的测试 

1、测试的补充代码

2、测试 

 本期学习目标：清楚什么是AVL树，模拟实现AVL树，理解四种旋转模型。 

一、AVL树基本知识

1、概念

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

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

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

 

2、节点定义

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

这里我们定义了三叉链来定义节点，最为特殊的是我们相对于二叉树，我们多了一个平衡 因子，这是维持AVL特性的关键，下面我们将围绕此展开对AVL树的构建。

注意：平衡因子 = 右树的高度-左树的高度

3、插入

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

1. 按照二叉搜索树的方式插入新节点

2. 调整节点的平衡因子

对于插入最为重要的是平衡因子的更新，下面我们将讨论更新平衡因子情况：

是否要在更新平衡因子，要根据子树的高度：
1、如果parent->_bf==0,者说明以前的parent->_bf==-1或者parent->_bf==1
即是以前是一边高一边低，现在是插入到矮的一边，树的高度不变，不更新

2、如果parent->_bf==-1或者parent->_bf==-1，者以前parent->_bf==0
即是以前树是均衡的，现在插入让一边高了
子树的高度变了，要向上更新

3 、如果parent->_bf==-2或者parent->_bf==2，者以前parent->_bf==-1或者parent->_bf==1
现在树严重不平衡，让树旋转维持结构

//插入
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->_left = cur;
		//更新parent
		cur->_parent = parent;
	}
	else
	{
		parent->_right = cur;
		//更新parent
		cur->_parent = parent;
	}

	//更新平衡因子
	while (parent)//parent为空，就更新到了根
	{
		//新增在树节点左边，parent->bf--
		//新增在树节点右边，parent->bf++
		if (cur == parent->_left)
		{
			parent->_bf--;
		}
		else
		{
			parent->_bf++;
		}

		//是否要在更新平衡因子，要根据子树的高度：
		//1、如果parent->_bf==0,者说明以前的parent->_bf==-1或者parent->_bf==1
		//即是以前是一边高一边低，现在是插入到矮的一边，树的高度不变，不更新

		//2、如果parent->_bf==-1或者parent->_bf==-1，者以前parent->_bf==0
		//即是以前树是均衡的，现在插入让一边高了
		//子树的高度变了，要向上更新

		//3 、如果parent->_bf==-2或者parent->_bf==2，者以前parent->_bf==-1或者parent->_bf==1
		//现在树严重不平衡，让树旋转维持结构

		//旋转：
		//1、让子树的高度差不差过1
		//2、旋转过程中也要保存搜索树结构
		//3、边更新平衡因子
		//4、让这课树的高度保存和之前一样(旋转结束，不影响上层结构)

		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)
			{
				RotateLR(parent);
			}
			//右左双旋
			else if (parent->_bf == 2 && cur->_bf == -1)
			{
				RotateRL(parent);
			}
			else
			{
				assert(false);
			}
			//旋转完成,平衡因子已经更新跳出循环
			break;
		}
		else
		{
			assert(false);
		}
	}
}

二、AVL树的旋转

如果parent->_bf==-2或者parent->_bf==2，者以前parent->_bf==-1或者parent->_bf==1
现在树严重不平衡，让树旋转维持结构：

旋转的要求：

  • 让子树的高度差不差过1
  • 旋转过程中也要保存搜索树结构
  • 边更新平衡因子
  • 让这课树的高度保存和之前一样(旋转结束，不影响上层结构)

旋转的分类： 

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

1、右单旋

对于可能出现右旋转的情况的子树是多样的

 这里我们可以根据需要进行右单旋转抽像图进行理解

 

代码实现： 

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

	//b做60的右
	parent->_left = subLR;

	if (subLR)
	{
		subLR->_parent = parent;
	}

	Node* ppNode = parent->_parent;
	//60做30的右
	subL->_right = parent;
	parent->_parent = subL;
	//60就是以前的根节点
	if (ppNode == nullptr)
	{
		_root = subL;
		subL->_parent = ppNode;
	}
	else
	{
		//上层父节点的左边是子树的parent
		if (ppNode->_left == parent)
		{
			ppNode->_left = subL;
		}
		else
		{
			ppNode->_right = subL;
		}

		subL->_parent = ppNode;
	}
	//更新平衡因子
	parent->_bf = subL->_bf = 0;
}

2、左单旋

 

代码实现：

 

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

	//让60左边链接到30的右边
	parent->_right = subRL;
	if (subRL)
	{
		subRL->_parent = parent;
	}

	Node* ppNode = parent->_parent;
	//让30变成60的左边
	subR->_left = parent;
	parent->_parent = subR;

	//subR就是根节点
	if (ppNode == nullptr)
	{
		_root = subR;
		_root->_parent = nullptr;
	}
	else
	{
		//上层父节点的左边是子树的parent
		if (ppNode->_left == parent)
		{
			ppNode->_left = subR;
		}
		else
		{
			ppNode->_right = subR;
		}

		//子树父节点和上层父节点链接
		subR->_parent = ppNode;
	}
	//更新平衡因子
	parent->_bf = subR->_bf = 0;
}

 3、左右双旋

对于双旋转来说：节点新增的位置不同，平衡因子最终也会不同，这里我们要进行分类讨论：

对于双旋转来说，最为重要的平衡因子的更新。 

 代码实现：

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

	//记录subLR的平衡因子
	int bf = subLR->_bf;
	RotateL(parent->_left);
	RotateR(parent);

	//根据不同情况更新平衡因子

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

4、 右左双旋

这里同样也要进行分类讨论：

 

代码实现： 

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

	//记录subLR的平衡因子
	int bf = subRL->_bf;
	RotateR (parent->_right);
	RotateL(parent);


	//根据不同情况更新平衡因子

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

三、AVL树的测试 

为了测试我们模拟实现的AVL树是否成功，还需要进行检查

1、测试的补充代码

树的高度：

int Height()
{
	return _Height(_root);
}
//求树的高度
int _Height(Node* root)
{
	//树高度为0
	if (root == nullptr)
	{
		return 0;
	}
	//递归求左树的高度
	int Lh = _Height(root->_left);
	//递归求右树的高度
	int Rh = _Height(root->_right);
	return  Lh > Rh ? Lh + 1 : Rh + 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->_bf << endl;
				cout << rightHeight - leftHeight << endl;
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}

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

中序遍历

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

2、测试 

完整代码：

#pragma once
#include<time.h>
#include<assert.h>

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

		//更新平衡因子
		while (parent)//parent为空，就更新到了根
		{
			//新增在树节点左边，parent->bf--
			//新增在树节点右边，parent->bf++
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			//是否要在更新平衡因子，要根据子树的高度：
			//1、如果parent->_bf==0,者说明以前的parent->_bf==-1或者parent->_bf==1
			//即是以前是一边高一边低，现在是插入到矮的一边，树的高度不变，不更新

			//2、如果parent->_bf==-1或者parent->_bf==-1，者以前parent->_bf==0
			//即是以前树是均衡的，现在插入让一边高了
			//子树的高度变了，要向上更新

			//3 、如果parent->_bf==-2或者parent->_bf==2，者以前parent->_bf==-1或者parent->_bf==1
			//现在树严重不平衡，让树旋转维持结构

			//旋转：
 

			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)
				{
					RotateLR(parent);
				}
				//右左双旋
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				else
				{
					assert(false);
				}
				//旋转完成,平衡因子已经更新跳出循环
				break;
			}
			else
			{
				assert(false);
			}
		}
	}
		void RotateL(Node * parent)
		{
			Node* subR = parent->_right;//父节点的右子树
			Node* subRL = subR->_left;//右树的左树

			//让60左边链接到30的右边
			parent->_right = subRL;
			if (subRL)
			{
				subRL->_parent = parent;
			}

			Node* ppNode = parent->_parent;
			//让30变成60的左边
			subR->_left = parent;
			parent->_parent = subR;

			//subR就是根节点
			if (ppNode == nullptr)
			{
				_root = subR;
				_root->_parent = nullptr;
			}
			else
			{
				//上层父节点的左边是子树的parent
				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;

			//b做60的右
			parent->_left = subLR;

			if (subLR)
			{
				subLR->_parent = parent;
			}

			Node* ppNode = parent->_parent;
			//60做30的右
			subL->_right = parent;
			parent->_parent = subL;
			//60就是以前的根节点
			if (ppNode == nullptr)
			{
				_root = subL;
				subL->_parent = ppNode;
			}
			else
			{
				//上层父节点的左边是子树的parent
				if (ppNode->_left == parent)
				{
					ppNode->_left = subL;
				}
				else
				{
					ppNode->_right = subL;
				}

				subL->_parent = ppNode;
			}
			//更新平衡因子
			parent->_bf = subL->_bf = 0;
		}

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

			//记录subLR的平衡因子
			int bf = subLR->_bf;
			RotateL(parent->_left);
			RotateR(parent);

			//根据不同情况更新平衡因子

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

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

			//记录subLR的平衡因子
			int bf = subRL->_bf;
			RotateR (parent->_right);
			RotateL(parent);


			//根据不同情况更新平衡因子

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

		int Height()
		{
			return _Height(_root);
		}
		//求树的高度
		int _Height(Node* root)
		{
			//树高度为0
			if (root == nullptr)
			{
				return 0;
			}
			//递归求左树的高度
			int Lh = _Height(root->_left);
			//递归求右树的高度
			int Rh = _Height(root->_right);
			return  Lh > Rh ? Lh + 1 : Rh + 1;
		}
		bool IsAVLTree()
		{
			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->_bf << endl;
				cout << rightHeight - leftHeight << endl;
				cout << root->_kv.first << "平衡因子异常" << endl;
				return false;
			}

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

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

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 };*/
	int a[] = { 30,60,90 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}

	t.InOrder();

	cout << t.IsAVLTree() << endl;
}
void TestAVLTree2()
{
	srand(time(0));
	const size_t N = 100000;
	AVLTree<int, int> t;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand();
		t.Insert(make_pair(x, x));
		/*cout << t.IsAVLTree() << endl;*/
	}
	cout << t.IsAVLTree() << endl;
}

这里我们分别进行简单 TestAVLTree1()和用生成随机数字生成的数字进行测试TestAVLTree2()

如果成功就会打印1.

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

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

相关文章

陪玩圈子系统APP小程序H5，详细介绍，源码交付，支持二开！

陪玩圈子系统APP小程序H5，详细介绍，源码交付，支持二开！

陪玩圈子系统&#xff0c;页面展示&#xff0c;源码交付&#xff0c;支持二开&#xff01; 陪玩后端下载地址&#xff1a;电竞开黑陪玩系统小程序&#xff0c;APP&#xff0c;H5: 本系统是集齐开黑&#xff0c;陪玩&#xff0c;陪聊于一体的专业APP&#xff0c;小程序&#xff…
阅读更多...
Github Copilot AI编码完成工具

Github Copilot AI编码完成工具

目录 一、GitHub Copilot 1、简介 2、工作原理 3、功能 二、GitHub Copilot X 1、什么是 GitHub Copilot X 2、GitHub Copilot X 的功能 三、支持、使用 1、支持 2、使用 四、实际研究、验证(代码方向) 1、代码生成 2、代码提示 3、生成测试用例 4、代码解释 5…
阅读更多...
排序算法--归并排序

排序算法--归并排序

实现逻辑 ① 将序列每相邻两个数字进行归并操作&#xff0c;形成floor(n/2)个序列&#xff0c;排序后每个序列包含两个元素 ② 将上述序列再次归并&#xff0c;形成floor(n/4)个序列&#xff0c;每个序列包含四个元素 ③ 重复步骤②&#xff0c;直到所有元素排序完毕 void pri…
阅读更多...
Rust并发编程：理解线程与并发

Rust并发编程：理解线程与并发

大家好&#xff01;我是lincyang。 今天我们来深入探讨Rust中的并发编程&#xff0c;特别是线程的使用和并发的基本概念。 Rust中的线程 Rust使用线程来实现并发。线程是操作系统可以同时运行的最小指令集。在Rust中&#xff0c;创建线程非常简单&#xff0c;但与此同时&…
阅读更多...
SHAP - 机器学习模型可解释性工具

SHAP - 机器学习模型可解释性工具

github地址&#xff1a;shap/docs/index.rst at master shap/shap (github.com) SHAP使用文档&#xff1a;欢迎使用 SHAP 文档 — SHAP 最新文档 SHAP介绍 SHAP&#xff08;SHapley Additive exPlanations&#xff09;是一种用于解释预测结果的方法&#xff0c;它基于Shapley…
阅读更多...
ADB命令介绍

ADB命令介绍

&#x1f4e2;专注于分享软件测试干货内容&#xff0c;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01;&#x1f4e2;交流讨论&#xff1a;欢迎加入我们一起学习&#xff01;&#x1f4e2;资源分享&#xff1a;耗时200小时精选的「软件测试」资…
阅读更多...
系列七、ThreadLocal为什么会导致内存泄漏

系列七、ThreadLocal为什么会导致内存泄漏

一、ThreadLocal为什么会导致内存泄露 1.1、ThreadLocalMap的基本结构 ThreadLocalMap是ThreadLocal的内部类&#xff0c;没有实现Map接口&#xff0c;用独立的方式实现了Map的功能&#xff0c;其内部的Entry也是独立实现的。源码如下&#xff1a; 1.2、ThreadLocal引用示意图…
阅读更多...
逸学java【初级菜鸟篇】9.3 Stream流

逸学java【初级菜鸟篇】9.3 Stream流

hi&#xff0c;我是逸尘&#xff0c;一起学java吧 得益于Lambda所带来的函数式编程&#xff0c;引入了一个全新的Stream流概念&#xff08;就是都基本使用lambda的形式&#xff09;。 流处理 我们首先理解什么是流处理&#xff0c;它类似于sql语句&#xff0c;可以执行非常复…
阅读更多...
cocos2dx ​​Animate3D（二）

cocos2dx ​​Animate3D（二）

Twirl 扭曲旋转特效 // 持续时间(时间过后不会回到原来的样子) // 整个屏幕被分成几行几列 // 扭曲中心位置 // 扭曲的数量 // 振幅 static Twirl* create(float duration, const Size& gridSize, const Vec2& position, unsigned int twirls, float amplitude)…
阅读更多...
Python基础【二】--基本语句【2023.11.22】

Python基础【二】--基本语句【2023.11.22】

1.条件语句 在进行逻辑判断时&#xff0c;我们需要用到条件语句&#xff0c;Python 提供了 if、elif、else 来进行逻辑判断。格式如下所示&#xff1a; if 判断条件1:执行语句1... elif 判断条件2:执行语句2... elif 判断条件3:执行语句3... else:执行语句4...ainput("请输…
阅读更多...
Django 模型和Admin站点管理（三）

Django 模型和Admin站点管理（三）

一、定义模型 &#xff08;1&#xff09; 创建模型类&#xff0c;必须要继承自 models.Model from django.db import models# Create your models here. #设计数据库 #创建模型 class UserModel(models.Model):namemodels.CharField(max_length30) #对应于SQL name varchar(30…
阅读更多...
EMG肌肉信号处理合集 (一）

EMG肌肉信号处理合集 (一）

本文归纳了常见的肌肉信号预处理流程&#xff0c;方便EMG信号的后续分析。使用pyemgpipeline库 来进行信号的处理。文中使用了 UC Irvine 数据库的下肢数据。 目录 1 使用wrappers 定义数据类&#xff0c;来进行后续的操作 2 肌电信号DC偏置去除 3 带通滤波器处理 4 对肌电…
阅读更多...
opencv-直方图

opencv-直方图

直方图是一种对图像亮度分布的统计表示&#xff0c;它显示了图像中每个灰度级别的像素数量。在OpenCV中&#xff0c;你可以使用cv2.calcHist() 函数计算直方图。 以下是一个简单的示例&#xff0c;演示如何计算和绘制图像的直方图&#xff1a; import cv2 import numpy as np …
阅读更多...
汽车级芯片NCV7518MWATXG 可编程六沟道低压侧 MOSFET预驱动器 特点、参数及应用

汽车级芯片NCV7518MWATXG 可编程六沟道低压侧 MOSFET预驱动器 特点、参数及应用

NCV7518MWATXG 可编程六沟道低压侧 MOSFET 预驱动器属于 FLEXMOS™ 汽车级产品&#xff0c;用于驱动逻辑电平 MOSFET。该产品可通过串行 SPI 和并行输入组合控制。该器件提供 3.3 V/5 V 兼容输入&#xff0c;并且串行输出驱动器可以采用 3.3 V 或 5 V 供电。内部通电重置提供受…
阅读更多...
逸学java【初级菜鸟篇】9.4 泛型

逸学java【初级菜鸟篇】9.4 泛型

hi&#xff0c;我是逸尘&#xff0c;一起学java吧 泛型概述 泛型是我们在定义某一个类型规格的时候使用的泛指&#xff0c;我们预先定义一个大方向&#xff0c;防止路线错误。 实质上是程序员定义的安全类型&#xff0c;Object是顶级父类&#xff0c;在没有泛型很多程序员为了…
阅读更多...
【Django使用】md文档10大模块第5期：Django数据库增删改查和Django视图

【Django使用】md文档10大模块第5期：Django数据库增删改查和Django视图

Django的主要目的是简便、快速的开发数据库驱动的网站。它强调代码复用&#xff0c;多个组件可以很方便的以"插件"形式服务于整个框架&#xff0c;Django有许多功能强大的第三方插件&#xff0c;你甚至可以很方便的开发出自己的工具包。这使得Django具有很强的可扩展…
阅读更多...
PTA-矩阵A乘以B

PTA-矩阵A乘以B

给定两个矩阵A和B&#xff0c;要求你计算它们的乘积矩阵AB。需要注意的是&#xff0c;只有规模匹配的矩阵才可以相乘。即若A有Ra​行、Ca​列&#xff0c;B有Rb​行、Cb​列&#xff0c;则只有Ca​与Rb​相等时&#xff0c;两个矩阵才能相乘。 输入格式&#xff1a; 输入先后…
阅读更多...
【JavaSE】-4-单层循环结构

【JavaSE】-4-单层循环结构

回顾 运算符&#xff1a; 算术 --、逻辑 && & || |、比较 、三元 、赋值 int i 1; i; j i; //j2 i3 syso(--j"-----"i) //1 3 选择结构 if(){} if(){}else{} if(){}else if(){}else if(){}else{}//支持byte、short、int //支持char //支持枚举…
阅读更多...
回归算法优化过程推导

回归算法优化过程推导

假设存在一个数据集&#xff0c;包含工资、年龄及贷款额度三个维度的数据。我们需要根据这个数据集进行建模&#xff0c;从而在给定工资和年龄的情况下&#xff0c;实现对贷款额度的预测。其中&#xff0c;工资和年龄是模型构建时的两个特征&#xff0c;额度是模型输出的目标值…
阅读更多...
Axios使用方式

Axios使用方式

ajax是JQUERY封装的XMLHttprequest用来发送http请求 Axios简单点说它就是一个js库,支持ajax请求,发送axios请求功能更加丰富,丰富在哪不知道 1.npm使用方式 vue项目中 npm install axios 2.cdn方式 <script src"https://unpkg.com/axios/dist/axios.min.js">…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023