AVL——平衡搜索树

news2024/11/20 23:26:47

✅<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->_parent = pparent;
		}
		//修改平衡因子
		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 (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;
	}

3.左右双旋

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

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

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

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

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

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

		//先左单旋
		RotateL(curL);
        //再右单旋
		RotateR(parent);
        
        //保存curLR的平衡因子，判断插入结点的位置，根据插入结点的位置，
        //判断出其他结点的平衡因子
		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);
		}
	}

4.右左双旋

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

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

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

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

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

相关文章

微服务中间件--统一网关Gateway

微服务中间件--统一网关Gateway

统一网关Gateway 8.统一网关Gatewaya.搭建网关服务b.路由断言工厂c.路由过滤器GatewayFilterd.全局过滤器GlobalFiltere.过滤器的执行顺序f.网关的cors跨域配置 8.统一网关Gateway 网关功能&#xff1a; 身份认证和权限校验服务路由、负载均衡请求限流 网关的技术实现 在Spr…
阅读更多...
基于大数据+django+mysql的银行信用卡用户的数仓系统

基于大数据+django+mysql的银行信用卡用户的数仓系统

系统阐述的是银行信用卡用户的数仓系统的设计与实现&#xff0c;对于Python、B/S结构、MySql进行了较为深入的学习与应用。主要针对系统的设计&#xff0c;描述&#xff0c;实现和分析与测试方面来表明开发的过程。开发中使用了 django框架和MySql数据库技术搭建系统的整体架构…
阅读更多...
国民新旅游时代拉开大幕，OTA平台迎来新红利和新任务

国民新旅游时代拉开大幕，OTA平台迎来新红利和新任务

高温轮番而至&#xff0c;这个燥热的夏天&#xff0c;旅游业也躁动不已。 上半年是旅游业丰收的半年&#xff0c;各地旅游盛况频上热搜。文旅部公布的旅游数据显示&#xff0c;2023年上半年&#xff0c;国内旅游总人次23.84亿&#xff0c;同比增长63.9%&#xff1b;国内旅游收…
阅读更多...
IO day 7

IO day 7

1、使用消息队列完成两个进程间相互通信 msgsnd #include <myhead.h>typedef struct {long msgtype;char data[1024]; }Msg_ds;#define SIZE sizeof(Msg_ds)-sizeof(long)int main(int argc, const char *argv[]) {//创建key值key_t key;if((key ftok("/",k…
阅读更多...
Feign:使用接口方式调用服务

Feign:使用接口方式调用服务

创建一个新的消费者模块并导入依赖 <?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://ma…
阅读更多...
创建k8s operator

创建k8s operator

目录 1.前提条件 2.进一步准备 2.1.安装golang 2.2.安装code&#xff08;vscode的linux版本&#xff09; 2.3.安装kubebuilder 3.开始创建Operator 3.1.什么是operator? 3.2.GV & GVK & GVR 3.3.创建operator 3.3.1. 生成工程框架 3.3.2.生成api(GVK) …
阅读更多...
C++设计模式之适配器模式

C++设计模式之适配器模式

一、适配器模式 适配器模式&#xff08;Adapter Pattern&#xff09;是一种结构型设计模式&#xff0c;用于将一个类的接口转换成另一个类所期望的接口&#xff0c;以便两个类能够协同工作。 适配器模式可以解决现有类接口与所需接口不匹配的问题&#xff0c;使得原本因接口不…
阅读更多...
JavaScript下载excel文件

JavaScript下载excel文件

文章目录 通过链接下载a标签下载方法注意 获取文件流请求体配置下载文件流 总结 通过链接下载 a标签 对于已知地址的目标文件&#xff0c;前端可以使用 a标签 来直接下载&#xff0c;使用a标签下载使用到两个属性 download&#xff1a;下载文件名href&#xff1a;目标文件下…
阅读更多...
ORA-01174: DB_FILES be compatible RAC rolling fashion complete outage

ORA-01174: DB_FILES be compatible RAC rolling fashion complete outage

How to change the DB_FILES parameter in RAC (Doc ID 1636681.1)​编辑To Bottom In this Document Goal Solution APPLIES TO: Oracle Database - Enterprise Edition - Version 10.1.0.2 and later Oracle Database Cloud Schema Service - Version N/A and later Oracle…
阅读更多...
【业务功能篇75】微服务项目环境搭建docker-mysql-redisSpringCloudAlibaba

【业务功能篇75】微服务项目环境搭建docker-mysql-redisSpringCloudAlibaba

项目环境准备 1.虚拟机环境 我们可以通过VMWare来安装&#xff0c;但是通过VMWare安装大家经常会碰到网络ip连接问题&#xff0c;为了减少额外的环境因素影响&#xff0c;Docker内容的讲解我们会通过VirtualBox结合Vagrant来安装虚拟机。 VirtualBox官网&#xff1a;https:/…
阅读更多...
《热题101》链表篇

《热题101》链表篇

思路&#xff1a;之前有反转链表前n个值、以及反转指定区间的链表&#xff0c;所以这个我只想在这两个基础上实现。用左右指针来确定当前反转的区间&#xff0c;每次反转之前都检查一下当前区间是否足够k&#xff0c;即区间之后的节点cur&#xff0c;足够就可以反转&#xff0c…
阅读更多...
【Flink】Flink架构及组件

【Flink】Flink架构及组件

我们学习大数据知识的时候&#xff0c;需要知道大数据组件如何安装以及架构组件&#xff0c;这将帮助我们更好的了解大数据组件 对于大数据Flink&#xff0c;架构图图下&#xff1a; 整个架构图有三种关键组件 1、Client&#xff1a;负责作业的提交。调用程序的 main 方法&am…
阅读更多...
基于乌鸦算法优化的BP神经网络（预测应用） - 附代码

基于乌鸦算法优化的BP神经网络（预测应用） - 附代码

基于乌鸦算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码 文章目录 基于乌鸦算法优化的BP神经网络&#xff08;预测应用&#xff09; - 附代码1.数据介绍2.乌鸦优化BP神经网络2.1 BP神经网络参数设置2.2 乌鸦算法应用 4.测试结果&#xff1a;5.Matlab代码 摘要…
阅读更多...
Spring练习31---用户添加操作--添加数据到数据库，最终添加讲师，助教操作最终完毕

Spring练习31---用户添加操作--添加数据到数据库，最终添加讲师，助教操作最终完毕

视频链接&#xff1a;16-Spring练习-用户添加操作-添加数据到数据库_哔哩哔哩_bilibili 104 1、当你点击提交时&#xff0c;form表单进行提交 2、这个名字必须跟你当前封装的属性名一样 3、要封装跟user的属性名一样&#xff0c;这样springMVc才能自动封装进去 4、提交时选择r…
阅读更多...
Cyanine5-alkyne在无机纳米领域的应用-星戈瑞

Cyanine5-alkyne在无机纳米领域的应用-星戈瑞

​欢迎来到星戈瑞荧光stargraydye&#xff01;小编带您盘点&#xff1a; Cyanine5-alkyne在无机纳米领域也有着诸多的应用&#xff0c;主要体现在以下几个方面&#xff1a; **1. 纳米颗粒表面功能化&#xff1a;**Cyanine5-alkyne作为反应性的炔基官能团&#xff0c;可以与含有…
阅读更多...
springboot之@Async异步定时任务自定义线程池

springboot之@Async异步定时任务自定义线程池

在应用中经常会遇到定时执行任务的需求&#xff0c;这时采用异步的方式开启一个定时任务&#xff0c;通常引用Async注解&#xff0c;但直接使用会有风险&#xff0c;当我们没有指定线程池时&#xff0c;会默认使用其Spring自带的 SimpleAsyncTaskExecutor 线程池&#xff0c;会…
阅读更多...
Elasticsearch Split和shrink API

Elasticsearch Split和shrink API

背景&#xff1a; 尝试解决如下问题&#xff1a;单分片存在过多文档&#xff0c;超过lucene限制 分析 1.一般为日志数据或者OLAP数据&#xff0c;直接删除索引重建 2.尝试保留索引&#xff0c;生成新索引 - 数据写入新索引&#xff0c;查询时候包含 old_index,new_index 3.…
阅读更多...
一、数据库基础

一、数据库基础

数据库 一、数据库基础 1、一些概念 数据库&#xff1a;数据库&#xff08;DataBase &#xff0c;简称DB&#xff09;&#xff0c;就是信息的集合。数据库是由数据库管理系统管理的数据的集合&#xff1b;数据库管理系统&#xff1a;简称DBMS 。是一种操纵和管理数据库的大型…
阅读更多...
听GPT 讲Prometheus源代码--tsdb

听GPT 讲Prometheus源代码--tsdb

题图来自 Prometheus TSDB (Part 1): The Head Block[1] tsdb 目录在 Prometheus 项目中承担了实现时间序列数据库&#xff08;Time Series Database&#xff09;的功能。Prometheus 使用这个自定义的时间序列数据库来高效地存储和查询监控数据。 在 tsdb 目录下&#xff0c;有…
阅读更多...
这所C9无歧视！专业课简单，平均130分！

这所C9无歧视！专业课简单，平均130分！

一、学校及专业介绍 哈尔滨工业大学&#xff08;Harbin Institute of Technology&#xff0c;简称哈工大&#xff09;&#xff0c;是隶属于工业和信息化部的全国重点大学&#xff0c;位于哈尔滨市&#xff0c;九校联盟“C9”之一&#xff0c;位列国家“双一流”、“985工程”、…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023