【数据结构】AVL树的插入与验证

news2025/1/21 12:18:53

文章目录

  • 一、基本概念
    • 1.发展背景
    • 2.性质
  • 二、实现原理
    • ①插入操作
      • 1.平衡因子
        • 1.1平衡因子的更新
          • 1.1.1树的高度变化
          • 1.1.2树的高度不变
      • 2. 旋转
        • 2.1左旋
        • 2.2右旋
        • 2.3右左双旋
        • 2.4 左右双旋
    • ②验证
      • 1.求二叉树高度
      • 2. 判断是否为AVL树
  • 源码
  • 总结

一、基本概念

1.发展背景

  • 普通的二叉搜索树在极端情况下会退化成类似链表的形状，从而使查找的效率降低至O(N)。

  • 在此基础上，苏联与以色列数学家Adelson-Velskii 与 苏联数学家Landis，发明出了 AVL树或者说平衡二叉搜索树。

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

注：第一张——Adelson-Velskii（1922-2014） ，第二张——Landis（1921——1997）

2.性质

  • 左右子树的高度差的绝对值不大于1
  • 每个子树都是AVL树。

说明：这样做的目的就是为了严格控制平衡，以便于提高查找效率，但是控制高度差一直为0是不可能的，至于为什么不能控制成0，假设只有两个结点必然存在1的高度差。

二、实现原理

①插入操作

1.平衡因子

英文名：balance factor

  • 目的：保证左右子树的高度差的绝对值不大于1
  • 大多数的实现方式：存放的是右子树与左子树的高度差

1.1平衡因子的更新

1.1.1树的高度变化

① 左边新增结点
在这里插入图片描述

② 右边新增结点

在这里插入图片描述

  • 总结
  1. 左边新增，根节点的平衡因子减1
  2. 右边新增，根节点的平衡因子加1
  3. 平衡因子从0变为1或者-1

继续分析：
 两种情况树的高度增加1，也就是平衡因子从0变为1或者-1，既然高度变化了，可能会导致上面的树不平衡。
如：
在这里插入图片描述

此时我们需要向上更新平衡因子，再根据右边高度变化与左边高度变化，决定根的平衡因子加1还是减1。

  • 推论：由于可能会向上更新平衡因子，那么AVL树是三叉链的结构。

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

1.1.2树的高度不变

① 左边新增结点

在这里插入图片描述
② 右边新增结点

在这里插入图片描述

  • 同理
  1. 左边新增，根节点的平衡因子减1
  2. 右边新增，根节点的平衡因子加1
  3. 平衡因子由1或者-1变为0

继续分析，这里的根节点的所在树的高度即——左右子树高度的最大值 + 1（根节点的高度）

左右子树的高度的最大值不变，即这颗树高度不变，即不用往上继续更新且达到平衡。

2. 旋转

  • 说明：旋转就是让不平衡的树再次平衡的手段。

  • 条件：平衡因子为2或者-2，即高度差的绝对值为2。

  • 补充：若平衡因子大于等于3，说明当前树就不是AVL树，需要检验之前的代码。

但是我们又得对情况进行分类讨论，因为不同情况让树再次平衡的旋转方式不同。

2.1左旋

  • 说明：也就是右边高度高，需要旋转来降低右边的高度，进而达到平衡。

一步一步分析，先来个最简单的：

在这里插入图片描述
此时，旋转过后平衡因子全变为0，且当前树达到平衡。注意此时3结点的左结点为空！(细节)

再举一个例子：

在这里插入图片描述

此时，旋转过后平衡因子1和3的平衡因子变为0，且当前树达到平衡，此时我们是不用管其它子树的，因为子树必然是AVL树，要不然更不到根节点就停止了。

最后来一个稍微复杂的例子：
在这里插入图片描述
此时，旋转过后平衡因子-5和0的平衡因子变为0，且当前树达到平衡。

这是具体的图便于辅助理解，然后我们再画出所有情况的抽象图：
在这里插入图片描述

  • 总结
  1. 只能在c部分上插入结点才可能会引发根节点左单旋,也就是说parent的右边为cur且新增结点在cur的右边。
  2. 旋转过后cur与parent的平衡因子变为0。
  • 细节
  1. b的父节点连接parent时，需要判断b部分是否为空。
  2. parent的父节点连接cur时，需要保存一下parent的父节点。
  3. 根据parent的父节点判断是否需要修改根节点，若为空则修改，若不为空，则将cur链接到parent的父节点，同时更新parent父节点的指向。
  • 实现代码
	void RotateL(Node* parent)
	{
		//画图分析：
		//操作的结点有cur,cur_left,ppnode
		Node* cur = parent->_right;
		Node* cur_left = cur->_left;
		//将parent的右节点改为cur_left
		parent->_right = cur_left;
		//改变cur_left父节点的转向
		//cur_left可能为空
		if (cur_left != nullptr)
		{
			cur_left->_parent = parent;
		}
		//将parent链接在cur的左边
		//为了更新cur的parent需要保存parent的父节点
		Node* ppnode = parent->_parent;

		cur->_left = parent;
		parent->_parent = cur;

		//ppnode可能为空
		if (ppnode == nullptr)
		{
			//需要修改根节点
			_root = cur;
			cur->_parent = nullptr;
		}
		else
		{
			//改变ppnode的指向
			if (ppnode->_left == parent)
			{
				ppnode->_left = cur;
			}
			else
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;

		}

		//更新平衡因子
		cur->_bf = parent->_bf = 0;

	}

2.2右旋

说明：也就是左边高度高，需要旋转来降低右边的高度，进而达到平衡。

跟左旋的分析方式一样。

先来个简单的感受一下：

在这里插入图片描述

此时，旋转过后平衡因子parent和cur的平衡因子变为0，且当前树达到平衡。

再举一个例子：
在这里插入图片描述
最后来一个稍微复杂的例子：
在这里插入图片描述

画出所有情况的抽象图：

在这里插入图片描述

  • 总结
  1. 只能在a部分上插入结点才可能会引发根节点右单旋,也就是说parent与cur与高度变化的c树的根节点在同一个方向且在parent的左
  2. 旋转过后cur与parent的平衡因子变为0。
  • 细节——同左旋
  1. b的父节点连接parent时，需要判断b部分是否为空。
  2. parent的父节点连接cur时，需要保存一下parent的父节点。
  3. 根据parent的父节点判断是否需要修改根节点，若为空则修改，若不为空，则将cur链接到parent的父节点，同时更新parent父节点的指向。
  • 实现代码：
		void RotateR(Node* parent)
		{
			//操作的结点
			Node* cur = parent->_left;
			Node* cur_right = cur->_right;

			//第一步：将cur_right链接到parent的left
			parent->_left = cur_right;
			//更改cur_right的父节点
			//注意：cur_right可能为空
			if (cur_right != nullptr)
			{
				cur_right->_parent = parent;
			}
			//第二步：将parent链接到cur的右结点。
			//先保存一下parent的父节点
			Node* ppnode = parent->_parent;

			cur->_right = parent;
			parent->_parent = cur;
			//ppnode为空说明需要修改根节点
			if (ppnode == nullptr)
			{
				_root = cur;
				cur->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
				{
					ppnode->_left = cur;
				}
				else
				{
					ppnode->_right = cur;
				}

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

		}

2.3右左双旋

  • 可以简单理解为，需要进行处理的左旋。

说明：单旋无法解决问题，原因是发生了拐弯，需要用右旋讲折线变为直线，再进行左旋。

因为情况有点多我们就来个简单的，直接化抽象图，看结论比较容易理解。

先来个简单的：
在这里插入图片描述
先右旋之后折线变成了直线，变成了左旋的形状，再进行左旋，最后的cur与cur_left与parent的平衡因子变成了0，最终cur_left变成了根节点。

再化抽象图：

初始状态
在这里插入图片描述

在这里插入图片描述
还是一样，不过得分两种情况进行讨论：

  1. 新增结点在c树上，会导致parent的平衡因子变为-1，cur的平衡因子变为0。
  2. 新增结点在b树上，会导致parent的平衡因子变为0，cur的平衡因子变为1
  3. 不管新增结点在谁上，cur_left的平衡因子都为0。

  • 看图分析，其实不看新增结点在谁身上，两种最终的旋转的结果是一样的，那我们其实只需先不看新增结点再画图，根据最终的结果再把新增结点添上，其实会更加直观。

  • 总结

  1. 新增结点在c树上，会导致parent的平衡因子变为-1，cur的平衡因子变为0。
  2. 新增结点在b树上，会导致parent的平衡因子变为0，cur的平衡因子变为1。
  3. cur_left为新增结点，parent与cur的结点全为0。
  • 实现代码：
	void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* cur_left = cur->_left;

		//CL——CurLeft
		int CL_bf = cur_left->_bf;
		RotateR(cur);
		RotateL(parent);
		//更新平衡因子
		if (CL_bf == 0)
		{
			cur->_bf = parent->_bf = cur_left->_bf = 0;
			//虽然没必要，但是起到了解耦的作用。
		}
		else if (CL_bf == 1)
		{
			parent->_bf = -1;
			cur->_bf = cur_left->_bf = 0;
		}
		else if(CL_bf == -1)
		{
			cur->_bf = 1;
			parent->_bf = cur_left->_bf = 0;
		}
		else
		{
			cout << __LINE__ << ":" << endl;
			perror("平衡因子有误");
			exit(-1);
		}
	}

2.4 左右双旋

  • 可以理解为，需要进行处理的右旋。

说明：单旋无法解决问题，原因是发生了拐弯，需要用左旋讲折线变为直线，再进行右旋。

分析方法跟右左双旋一样。

先来个简单的：

在这里插入图片描述
先左旋之后折线变成了直线，变成了右旋的形状，再进行右旋，最后的cur与cur_left与parent的平衡因子变成了0，最终cur_left变成了根节点。

再来个抽象的：
在这里插入图片描述
还是一样，不过得分两种情况进行讨论：

  1. 新增结点在c树上，会导致cur的平衡因子变为-1，parent的平衡因子变为0。
  2. 新增结点在b树上，会导致cur的平衡因子变为0，parent的平衡因子变为1
  3. 不管新增结点在谁上，cur_right的平衡因子都为0。
  • 总结
  1. cur_right平衡因子为1，说明新增结点在b树上，会导致cur的平衡因子变为0，parent的平衡因子变为1。
  2. cur_right的平衡因子为-1，新增结点在c树上，会导致cur的平衡因子变为-1，parent的平衡因子变为0。
  3. cur_right的平衡因子为0，cur与parent的平衡因子都变为0。
  4. 不管新增结点在谁上，cur_right的平衡因子都为0。
  • 代码实现
		void RotateLR(Node* parent)
		{
			Node* cur = parent->_left;
			Node* cur_right = cur->_right;
			int CR_bf = cur_right->_bf;

			RotateL(cur);
			RotateR(parent);

			if (CR_bf == 0)
			{
				parent->_bf = cur->_bf = cur_right->_bf = 0;
			}
			else if(CR_bf == 1)
			{
				cur->_bf = -1;
				parent->_bf = cur_right->_bf = 0;
			}
			else if (CR_bf == -1)
			{
				parent->_bf = 1;
				cur->_bf = cur_right->_bf = 0;
			}
			else
			{
				cout << __LINE__ << ":" << endl;
				perror("平衡因子有误");
				exit(-1);
			}
		}

②验证

说明：

  1. 根据定义验证每颗子树的高度差
  2. 需要判断当前的右子树的高度差是否等于平衡因子

直接根据平衡因子进行判断，有点监守自盗的感觉，你能保证自己更新的平衡因子就是正确的么？我都不敢保证。

1.求二叉树高度

  • 后序遍历
	size_t Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}

		int LHeight = Height(root->_left);
		int RHeight = Height(root->_right);


		return max(LHeight, RHeight) + 1;
	}

2. 判断是否为AVL树

	bool _IsAVLTree(Node* root)
	{
		if (root == nullptr)
		{
			return true;
		}
		int RHeight = Height(root->_right);
		int LHeight = Height(root->_left);

		if (abs(RHeight - LHeight) > 1 || root->_bf != RHeight - LHeight)
		{
			return false;
		}

		return _IsAVLTree(root->_left) && _IsAVLTree(root->_right);
	}

优化一下：

	bool IsAVLTree()
	{
		bool is_AVL = true;
		_IsAVLTree(_root, is_AVL);

		return is_AVL;
	}

	int _IsAVLTree(Node* root,bool& is_AVL)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int RHeight = _IsAVLTree(root->_right, is_AVL);
		int LHeight = _IsAVLTree(root->_left, is_AVL);

		if (abs(RHeight - LHeight) > 1 || root->_bf != RHeight - LHeight)
		{
			is_AVL = false;
		}
		return max(RHeight, LHeight) + 1;
	}

源码

#include<iostream>
#include<assert.h>
using namespace std;
namespace MY_STL
{
	template<class Key,class Val>
	struct  AVLTreeNode
	{
		typedef AVLTreeNode<Key, Val> Node;
		AVLTreeNode(const pair<Key,Val>& key = pair<Key,Val>())
			:_key(key.first)
			,_val(key.second)
			,_left(nullptr)
			,_right(nullptr)
			,_parent(nullptr)
			,_bf(0)
		{}

		Key _key;
		Val _val;
		//三叉链的结构
		Node* _left;
		Node* _right;
		Node* _parent;
		int _bf;
	};
	template<class Key, class Val>
	class AVLTree
	{
		typedef AVLTreeNode<Key, Val> Node;
	public:
		AVLTree()
		{}

		bool insert(const pair<Key,Val>& val)
		{
			//第一步：插入操作
			//如果根节点为空
			if (_root == nullptr)
			{
				_root = new Node(val);
				return true;
			}
			else
			{
				Node* cur = _root,*parent = _root;
				while (cur)
				{
					if (cur->_key > val.first)
					{
						parent = cur;
						cur = cur->_left;

					}
					else if(cur->_key < val.first)
					{
						parent = cur;
						cur = cur->_right;

					}
					else
					{
						return false;
					}
				}
				cur = new Node(val);
				if (parent->_key > val.first)
				{
					parent->_left = cur;
				}
				else
				{
					parent->_right = cur;
				}
				//更新新增结点的_parent
				cur->_parent = parent;

				//第二步：更新平衡因子
				//平衡因子：
				//1. 定义为右子树的高度减去左子树的高度
				//2. 合法范围为{-1,0,1}
				//3. 新增结点在左，父节点的平衡因子减1
				//4. 新增结点在右，父节点的平衡因子加1
				//5. 当父节点的平衡因子变为0——由-1变0或者1变0时，此时AVL树的高度不变
				//6. 当父节点的平衡因子变为1或者-1，AVL子树的高度变化，继续向上变化。
				//7. 当父节点的平衡因子变为2或者-2时，此时需要旋转，进行平衡
				//8. 当父节点为根节点时，此时需要结束循环。

				while (cur != _root)
				{
					//更新平衡因子
					if (parent->_left == cur)
					{
						//左减1
						(parent->_bf)--;
					}
					else
					{
						//右加1
						(parent->_bf)++;
					}
					//判断平衡因子
					if (parent->_bf == 0)
					{
						break;
					}
					else if (parent->_bf == 1 || parent->_bf == -1)
					{
						cur = parent;
						parent = cur->_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);
						//}
						if (parent->_bf == 2)
						{
							//左单旋
							if (cur->_bf == 1)
							{
								RotateL(parent);
							}
							else
							{
								RotateRL(parent);
							}
						}
						else
						{
							//右单旋
							if (cur->_bf == -1)
							{
								RotateR(parent);
							}
							else
							{
								RotateLR(parent);
							}
						}
						
						//旋转完成，树达到平衡
						break;
					}
				}
				

				return true;
			}
		}
		//根据定义进行判断
		bool IsAVLTree()
		{
			bool is_AVL = true;
			_IsAVLTree(_root, is_AVL);

			return is_AVL;

			//return _IsAVLTree(_root);
		}

		void Print()
		{
			_InOrder(_root);
			cout << endl;
		}
		//根据平衡因子进行判断
		//bool IsAVLTree()
		//{
		//	return _IsAVLTree(_root);
		//}

	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
		//bool _IsAVLTree(Node* root)
		//{
		//	if (root == nullptr)
		//		return true;
		//	if (root->_bf >= 2 || root->_bf <= -2)
		//	{
		//		return false;
		//	}
		//	else
		//	{
		//		return _IsAVLTree(root->_left) && _IsAVLTree(root->_right);
		//	}
		//}

		//bool IsAVLTree()
		//{
		//	bool is_AVL = true;
		//	_IsAVLTree(_root, is_AVL);

		//	return is_AVL;
		//}

		size_t Height(Node* root)
		{
			if (root == nullptr)
			{
				return 0;
			}

			int LHeight = Height(root->_left);
			int RHeight = Height(root->_right);


			return max(LHeight, RHeight) + 1;
		}
		int _IsAVLTree(Node* root,bool& is_AVL)
		{
			if (root == nullptr)
			{
				return 0;
			}
			int RHeight = _IsAVLTree(root->_right, is_AVL);
			int LHeight = _IsAVLTree(root->_left, is_AVL);

			if (abs(RHeight - LHeight) > 1 || root->_bf != RHeight - LHeight)
			{
				is_AVL = false;
			}
			return max(RHeight, LHeight) + 1;
		}

		bool _IsAVLTree(Node* root)
		{
			if (root == nullptr)
			{
				return true;
			}
			int RHeight = Height(root->_right);
			int LHeight = Height(root->_left);

			if (abs(RHeight - LHeight) > 1 || root->_bf != RHeight - LHeight)
			{
				return false;
			}

			return _IsAVLTree(root->_left) && _IsAVLTree(root->_right);
		}

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

			RotateL(cur);
			RotateR(parent);

			if (CR_bf == 0)
			{
				parent->_bf = cur->_bf = cur_right->_bf = 0;
			}
			else if(CR_bf == 1)
			{
				cur->_bf = -1;
				parent->_bf = cur_right->_bf = 0;
			}
			else if (CR_bf == -1)
			{
				parent->_bf = 1;
				cur->_bf = cur_right->_bf = 0;
			}
			else
			{
				cout << __LINE__ << ":" << endl;
				perror("平衡因子有误");
				exit(-1);
			}
		}
		void RotateRL(Node* parent)
		{
			Node* cur = parent->_right;
			Node* cur_left = cur->_left;

			//CL——CurLeft
			int CL_bf = cur_left->_bf;
			RotateR(cur);
			RotateL(parent);

			if (CL_bf == 0)
			{
				cur->_bf = parent->_bf = cur_left->_bf = 0;
			}
			else if (CL_bf == 1)
			{
				parent->_bf = -1;
				cur->_bf = cur_left->_bf = 0;
			}
			else if(CL_bf == -1)
			{
				cur->_bf = 1;
				parent->_bf = cur_left->_bf = 0;
			}
			else
			{
				cout << __LINE__ << ":" << endl;
				perror("平衡因子有误");
				exit(-1);
			}
		}

		void RotateL(Node* parent)
		{
			//画图分析：
			//操作的结点有cur,cur_left,ppnode
			Node* cur = parent->_right;
			Node* cur_left = cur->_left;
			//将parent的右节点改为cur_left
			parent->_right = cur_left;
			//改变cur_left父节点的转向
			//cur_left可能为空
			if (cur_left != nullptr)
			{
				cur_left->_parent = parent;
			}
			//将parent链接在cur的左边
			//为了更新cur的parent需要保存parent的父节点
			Node* ppnode = parent->_parent;

			cur->_left = parent;
			parent->_parent = cur;

			//ppnode可能为空
			if (ppnode == nullptr)
			{
				//需要修改根节点
				_root = cur;
				cur->_parent = nullptr;
			}
			else
			{
				//改变ppnode的指向
				if (ppnode->_left == parent)
				{
					ppnode->_left = cur;
				}
				else
				{
					ppnode->_right = cur;
				}
				cur->_parent = ppnode;

			}

			//更新平衡因子
			cur->_bf = parent->_bf = 0;

		}
		void RotateR(Node* parent)
		{
			//操作的结点
			Node* cur = parent->_left;
			Node* cur_right = cur->_right;

			//第一步：将cur_right链接到parent的left
			parent->_left = cur_right;
			//更改cur_right的父节点
			//注意：cur_right可能为空
			if (cur_right != nullptr)
			{
				cur_right->_parent = parent;
			}
			//第二步：将parent链接到cur的右结点。
			//先保存一下parent的父节点
			Node* ppnode = parent->_parent;

			cur->_right = parent;
			parent->_parent = cur;
			//ppnode为空说明需要修改根节点
			if (ppnode == nullptr)
			{
				_root = cur;
				cur->_parent = nullptr;
			}
			else
			{
				if (ppnode->_left == parent)
				{
					ppnode->_left = cur;
				}
				else
				{
					ppnode->_right = cur;
				}

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

		}
		Node* _root = nullptr;
	};
};

总结

 AVL树还有删除操作，等博主有空再补充，对于AVL树一般来说只需要弄懂一种单旋，一种双旋，再加一些细写处理，代码是不难的，难就难在了分类讨论+画图上。今天的分享就到这里了，如果感觉有所帮助，不妨点个赞鼓励一下吧！

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

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

相关文章

Linux常见进程类别

Linux常见进程类别

目录 常见进程类别 守护进程&精灵进程 任务管理 进程组 作业 作业 | 进程组 会话 w命令 守护进程 守护进程的创建 setsid()函数 daemon()函数 模拟实现daemon函数 前台进程 | 后台进程 僵尸进程 | 孤儿进程 僵尸进程的一些细节 守护进程 | 后台进程 守护…
阅读更多...
基于SSM的人事管理信息系统

基于SSM的人事管理信息系统

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
原生js实现的轮盘抽奖案例

原生js实现的轮盘抽奖案例

来到大学也是有二年了&#xff0c;吃饭最多的地方就是在食堂&#xff0c;经过这么久的时间&#xff0c;已经几乎是把每个窗口的菜都吃腻了&#xff0c;所以我打算做个轮盘抽奖的形式来决定我每天要吃些什么。 目录 实现效果图&#xff1a; 静态搭建 js代码 1.实现此功能的思路…
阅读更多...
回归预测 | MATLAB实现PSO-SDAE粒子群优化堆叠去噪自编码器多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现PSO-SDAE粒子群优化堆叠去噪自编码器多输入单输出回归预测（多指标，多图）

回归预测 | MATLAB实现PSO-SDAE粒子群优化堆叠去噪自编码器多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09; 目录 回归预测 | MATLAB实现PSO-SDAE粒子群优化堆叠去噪自编码器多输入单输出回归预测&#xff08;多指标&#xff0c;多图&#xff09;效果一览…
阅读更多...
静态链表处理

静态链表处理

静态链表是指使用数组来表示节点。在C中&#xff0c;可以使用数组来创建静态列表&#xff0c;其中每个元素都有固定的位置和索引。可以通过下标寻址的方式来访问和操作列表中的元素。 单向列表&#xff1a; struct linkednode{int data;int next; }node[N]; 双向链表&#x…
阅读更多...
uniapp分包

uniapp分包

1.配置manifest.json “mp-weixin”: { “optimization”:{“subPackages”:true} } 第二步&#xff1a; 然后我们需要把页面放在这个几个分包中。 然后打开pages.json: "subPackages": [{//分包的所有的路径都在该方法中声明 { "root&qu…
阅读更多...
电子信息工程专业课复习知识点总结：(二）模电

电子信息工程专业课复习知识点总结：(二）模电

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言第一章 绪论1.信号2.信号的频谱3.模拟信号和数字信号4.放大电路模型 第二章 运算放大器1.集成电路运算放大器&#xff08;Integrated Circuit-OPA&#xff09;2…
阅读更多...
【实践篇】Redis最强Java客户端(三)之Redisson 7种分布式锁使用指南

【实践篇】Redis最强Java客户端(三)之Redisson 7种分布式锁使用指南

文章目录 0. 前言1. Redisson 7种分布式锁使用指南1.1 简单锁&#xff1a;1.2 公平锁&#xff1a;1.3 可重入锁&#xff1a;1.4 红锁&#xff1a;1.5 读写锁&#xff1a;1.6 信号量&#xff1a;1.7 闭锁&#xff1a; 2. Spring boot 集成Redisson 验证分布式锁3. 参考资料4. 源…
阅读更多...
测开之路：大厂测试开发工作四年的感悟

测开之路：大厂测试开发工作四年的感悟

经历 在两个大厂分别做了两年的测试开发工作&#xff0c;暂且成为 N 厂和 A 厂吧。负责过游戏自动化框架开发、专项测试工具开发、版本质量保障、Devops 平台开发&#xff0c;也带过小团队。每个厂&#xff0c;每份工作都力求突破&#xff0c;过程辛苦&#xff0c;自然结果都是…
阅读更多...
MYSQL的索引使用注意

MYSQL的索引使用注意

索引并不是时时都会生效的&#xff0c;比如以下几种情况&#xff0c;将导致索引失效 最左前缀法则 如果使用了联合索引&#xff0c;要遵守最左前缀法则。最左前缀法则指的是查询从索引的最左列开始&#xff0c; 并且不跳过索引中的列。如果跳跃某一列&#xff0c;索引将会部分…
阅读更多...
【PTA】浙江大学计算机与软件学院2019年考研复试上机自测

【PTA】浙江大学计算机与软件学院2019年考研复试上机自测

个人学习记录&#xff0c;代码难免不尽人意。 呃&#xff0c;今天做了做19年的复试上机题&#xff0c;死在hash表上了&#xff0c;后面详细解释。心态要好&#xff0c;心态要好 7-1 Conway’s Conjecture John Horton Conway, a British mathematician active in recreational…
阅读更多...
用友U8与MES系统API接口对接案例分析

用友U8与MES系统API接口对接案例分析

企业数字化转型&#xff1a;轻易云数据集成平台助力 U8 ERPMES 系统集成 为什么选择数字化转型&#xff1f; 领导层对企业资源规划&#xff08;ERP&#xff09;的深刻理解促使了数字化转型的启动。采用精确的“N5”滚动计划&#xff0c;为供应商提供充分的预期信息&#xff0c…
阅读更多...
MyBatis中的几种查询结果集返回类型映射

MyBatis中的几种查询结果集返回类型映射

MyBatis中的几种查询结果集返回类型映射 一、MyBatis查询结果类型 MyBatis查询是比较常用的功能操作&#xff0c;对于查询语句来说&#xff0c;它是需要返回查询结果的&#xff0c;不同查询可以返回不同类型的查询结果&#xff0c;例如&#xff1a;查询记录总数&#xff0c;那…
阅读更多...
SSM - Springboot - MyBatis-Plus 全栈体系（四）

SSM - Springboot - MyBatis-Plus 全栈体系（四）

第二章 SpringFramework 四、SpringIoC 实践和应用 1. SpringIoC / DI 实现步骤 1.1 配置元数据&#xff08;配置&#xff09; 配置元数据&#xff0c;既是编写交给SpringIoC容器管理组件的信息&#xff0c;配置方式有三种。基于 XML 的配置元数据的基本结构&#xff1a; …
阅读更多...
LabVIEW通过IEC61508标准验证ITER联锁系统

LabVIEW通过IEC61508标准验证ITER联锁系统

LabVIEW通过IEC61508标准验证ITER联锁系统 保护环境要求系统能够保护机器免受工厂系统故障或机器危险操作造成的严重损坏。负责此功能的ITER系统是联锁控制系统&#xff08;ICS&#xff09;。该系统通过中央联锁系统&#xff08;CIS&#xff09;监督和控制不同的工厂联锁系统&…
阅读更多...
javaee springMVC 一个案例

javaee springMVC 一个案例

项目结构 pom.xml <?xml version"1.0" encoding"UTF-8"?><project xmlns"http://maven.apache.org/POM/4.0.0" xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.apache.org/P…
阅读更多...
分布式锁使用

分布式锁使用

1、在微服务项目中&#xff0c;上面的锁方法只能锁住一个单体的&#xff0c;分布式需要使用分布式锁 redis中的setnx 问题&#xff1a; 但是&#xff0c;如果进入判断后&#xff0c;还没执行到过期时间语句就断电&#xff0c;那也会死锁&#xff0c;所以应该使用 但是如果执行…
阅读更多...
Linux命令200例：mkfs用于创建文件系统

Linux命令200例：mkfs用于创建文件系统

&#x1f3c6;作者简介&#xff0c;黑夜开发者&#xff0c;CSDN领军人物&#xff0c;全栈领域优质创作者✌。CSDN专家博主&#xff0c;阿里云社区专家博主&#xff0c;2023年6月csdn上海赛道top4。 &#x1f3c6;数年电商行业从业经验&#xff0c;历任核心研发工程师&#xff0…
阅读更多...
(文章复现)基于主从博弈的新型城镇配电系统产消者竞价策略

(文章复现)基于主从博弈的新型城镇配电系统产消者竞价策略

参考文献&#xff1a; [1]陈修鹏,李庚银,夏勇.基于主从博弈的新型城镇配电系统产消者竞价策略[J].电力系统自动化,2019,43(14):97-104. 1.基本原理 在竞争性电力市场下&#xff0c;新型城镇配电系统内主要有以下几类主体&#xff1a;电力交易中心和调度部门、产消者、电网公共…
阅读更多...
WebSocket的那些事（5-Spring STOMP支持之连接外部消息代理）

WebSocket的那些事（5-Spring STOMP支持之连接外部消息代理）

目录 一、序言二、开启RabbitMQ外部消息代理三、代码示例1、Maven依赖项2、相关实体3、自定义用户认证拦截器4、Websocket外部消息代理配置5、ChatController6、前端页面chat.html 四、测试示例1、群聊、私聊、后台定时推送测试2、登录RabbitMQ控制台查看队列信息 五、结语 一、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023