二叉树之AVL树

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量635 收藏 13
点赞数 8
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81758005/article/details/140870668
版权

一、AVL树的概念

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

AVL树的性质

a：它的左右子树都是AVL树

b：左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

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

二、AVL树的实现

1、结点的定义

template<class T>
struct AVLNode {
	AVLNode(T key = T())
		:left(nullptr)
		, right(nullptr)
		，parent(nullptr)
		, _key(key)
		, bf(0);
	{}
	T _key;
	int bf;//平衡因子
	AVLNode<T>* left;
	AVLNode<T>* right;
	AVLNode<T>* parent;//该结点的父结点（双亲）
};

这里要用三叉链的原因是方便向上找祖先的平衡因子。 （也可以用栈来存储平衡因子，这样就不用三叉链了）。

2、AVL树的插入

分析：

插入结点会影响部分祖先结点的平衡因子，所以要更新平衡因子。

这里我定义的高度差是右树减左树，所以插入结点父结点的平衡因子与插入结点的位置有关。

插在左子树平衡因子 -1；插在右子树平衡因子+1；

至于是否继续向上更新祖先的平衡因子，是要看以插入结点的父结点作为根的子树的高度是否会变化。

1、parent的平衡因子==0

说明parent的平衡因子更新前是 1 or -1，插入结点插入在矮的一侧，此时parent所在子树高度不变，不需要向上更新平衡因子。

2、parent的平衡因子==1 or -1

说明parent的平衡因子更新前是0，插入结点插入在parent的左右任意一侧，此时parent所在子树的高度发生变化，需要向上更新平衡因子。

3、parent的平衡因子== 2 or -2

说明parent的平衡因子更新前是1 or -1，插入结点插入在高的一侧，进一步加剧了左右高度差，此时需要旋转来操作平衡。

大体框架：

1、除去旋转的大体框架
bool insert(const T& key)
{
	if (_root == nullptr)//空树的情况
	{
		_root = new Node(key);
		return true;
	}
	Node* pcur = _root;
	Node* pre = nullptr;
	while (pcur)//插入树里面不存在的值，pcur一定会走向空
	{
		pre = pcur;//插入位置的父节点
		if (pcur->_key < key)
		{
			pcur = pcur->right;
		}
		else if (pcur->_key > key)
		{
			pcur = pcur->left;
		}
		else//插入的值已存在，无需插入
		{
			return false;
		}
	}
	pcur = new Node(key);//作为插入的新结点
	if (pre->_key < key)
		pre->right = pcur;
	else 
		pre->left = pcur;
	pcur->parent = pre;//链接父子结点
	// 插入完成后更新并检查平衡因子，不满足平衡条件的，旋转
	while (pre)
	{
		//更新平衡因子
		if(pre->right == pcur)
			++pre->bf;//插在右子树平衡因子+1
		if(pre->left == pcur)
			--pre->bf;//插在左子树平衡因子 -1
		//更新后检查平衡因子
		if (pre->bf == 0)
			break;
		else if (pre->bf == -1 || pre->bf == 1)//插入前平衡因子是0，插入后改变了树的高度
		{
			pcur = pre;//pcur=pcur->parent
			pre = pre->parent;//向上继续判断
		}
		else if (pre->bf == 2 || pre->bf == -2)//插入前平衡因子不是1就是-1
		{
			//旋转处理
			//注意旋转处理完了要跳出循环
			break;//此时要跳出循环，(因为旋转后，原来根结点的位置发生改变，且此时平衡因子出现问题的那棵子树达到平衡），不然会出问题（因为这个调试了半天）
		}
		else
			assert(false);//平衡因子绝对值大于2说明旋转操作有问题，此时断言错误
	}
	return true;
}
2、旋转的分析

情况一：单纯的左子树高（插在subL的左子树上）

此时需要右单旋来达到平衡：

if (pre->bf == -2 && pcur->bf == -1)//左子树高
				RotateR(pre);
//右单旋（左子树高）此时插入结点的位置是subL的左子树上
void RotateR(Node* root)
{
	Node* subL = root->left;//左子树的根结点
	Node* subLR = subL->right;
	root->left = subLR;
	if (subLR)//不为空则链接
	{
		subLR->parent = root;
	}
	subL->right = root;
	if (root->parent == nullptr)//整个二叉树的根结点出现问题
	{
		_root = subL;//更新根结点
	}
	else//更换了子树根的位置，需要重新链接，避免出现4插链的情况
	{
		if (root == root->parent->left)
			root->parent->left = subL;
		if(root == root->parent->right)
			root->parent->right = subL;
	}
	subL->parent = root->parent;
	root->parent = subL;
	//更新平衡因子
	subL->bf = 0;
	root->bf = 0;
}

情况二：单纯的右子树高（插在subR的右子树上）

此时需要左单旋来达到平衡：

 

 

else if(pre->bf == 2 && pcur->bf == 1)//右子树高
				RotateL(pre);
//左单旋（右子树高）此时插入结点的位置是subR的右子树上
void RotateL(Node* root)
{
	Node* subR = root->right;
	Node* subRL = subR->left;
	root->right = subRL;
	if (subRL)//不为空
	{
		subRL->parent = root;
	}
	subR->left = root;
	if (root->parent == nullptr)//整个二叉树的根结点出现问题
	{
		_root = subR;//更新根结点
	}
	else//更换了子树根的位置，需要重新链接，避免出现4插链的情况
	{
		if (root == root->parent->left)
			root->parent->left = subR;
		if (root == root->parent->right)
			root->parent->right = subR;
	}
	subR->parent = root->parent;
	root->parent = subR;
	//更新平衡因子
	root->bf = 0;
	subR->bf = 0;
}

情况三：左子树高，但是插在subL的右子树上

此时需要先以subL(pcur)为根左旋，然后再以root(pre)为根右旋来达到平衡：

1、以subL(pcur)为根左旋：

2、以root(pre)为根右旋：

整个具体的过程：

这里的平衡因子还有两种情况要分开讨论：

(1)add插在subLR的左子树上(subLR->bf==-1)：此时两次旋转完成后subL的平衡因子为0，root的平衡因子为1

(2)add插在subLR的右子树上(subLR->bf==1)：此时两次旋转完成后subL的平衡因子为-1，root的平衡因子为0

else if (pre->bf == -2 && pcur->bf == 1)//左子树高但是插在subL的右子树上
{
				RotateLR(pre);
}
//左旋+右旋（左子树高但是插在subL的右子树上）
void RotateLR(Node* root)
{
	Node* subL = root->left;
	Node* subLR = subL->right;
	int bf = subLR->bf;//记录，用于判断更新情况
	RotateL(subL);
	RotateR(root);
	if (bf == 0)
	{
		root->bf = 0;
		subL->bf = 0;
		subLR->bf = 0;
	}
	else if (bf == -1)
	{
		root->bf = 1;
		subL->bf = 0;
		subLR->bf = 0;
	}
	else if (bf == 1)
	{
		root->bf = 0;
		subL->bf = 0;
		subLR->bf = 1;
	}
	else
		assert(false);
}

情况四：右子树高但插在subR的左子树上

此时需要先以subR(pcur)为根右旋，然后再以root(pre)为根左旋来达到平衡：

1、以subR(pcur)为根右旋：

2、以root(pre)为根左旋：

整个具体的过程：

这里的平衡因子还有两种情况要分开讨论：

(1)add插在subRL的左子树上(subRL->bf==-1)：此时两次旋转完成后subR的平衡因子为1，root的平衡因子为0

(2)add插在subLR的右子树上(subRL>bf==1)：此时两次旋转完成后subR的平衡因子为0，root的平衡因子为-1

else if (pre->bf == 2 && pcur->bf == -1)//右子树高但是插在subR的左子树上
{
				RotateRL(pre);
}
//右旋+左旋（右子树高但是插在subR的左子树上）
void RotateRL(Node* root)
{
	Node* subR = root->right;
	Node* subRL = subR->left;
	int bf = subRL->bf;
	RotateR(subR);
	RotateL(root);
	if (bf == 0)
	{
		subR->bf = 0;
		subRL->bf = 0;
		root->bf = 0;
	}
	else if (bf == 1)
	{
		subR->bf = 0;
		subRL->bf = 0;
		root->bf = -1;
	}
	else if (bf == -1)
	{
		subR->bf = 1;
		subRL->bf = 0;
		root->bf = 0;
	}
	else
		assert(false);
}

三、 AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树:

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

2. 验证其为平衡树:

每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子);节点的平衡因子是否计算正确

int _Height(Node* root)
{
	if (root == nullptr)
		return 0;
	int leftH = _Height(root->left);
	int rightH = _Height(root->right);
	return leftH > rightH ? leftH + 1 : rightH + 1;
}
bool IsBalance(Node* root)
{
	if (nullptr == root)
		return true;
	int leftHeight = _Height(root->left);
	int rightHeight = _Height(root->right);
	int diff = rightHeight - leftHeight;
	if (abs(diff) > 1)
	{
		cout << "高度差出现问题" << endl;
		return false;
	}
	if (diff != root->bf)
	{
		cout << "平衡因子出现问题" << endl;
		return false;
	}
	return IsBalance(root->left) && IsBalance(root->right);
}

测试用例：

int arr1[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
int arr2[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

源码：

#include<iostream>
#include<assert.h>
using namespace std;
template<class T>
struct AVLNode {
	AVLNode(T key = T())
		:left(nullptr)
		, right(nullptr)
		, parent(nullptr)
		, _key(key)
		, bf(0)
	{}
	T _key;
	int bf;//平衡因子
	AVLNode<T>* left;
	AVLNode<T>* right;
	AVLNode<T>* parent;
};

// AVL: 二叉搜索树 + 平衡因子的限制
template<class T>
class AVLTree {
public:
	typedef AVLNode<T> Node;
	AVLTree() = default;
	~AVLTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	void InOrder()
	{
		_InOrder(_root);//成员函数可以访问私有
	}
	int Height()
	{
		return _Height(_root);
	}
	Node* GetNode()//给外界提供获得私有结点的方式，便于调试
	{
		return _root;
	}
	bool IsBalance(Node* root)
	{
		if (nullptr == root)
			return true;
		int leftHeight = _Height(root->left);
		int rightHeight = _Height(root->right);
		int diff = rightHeight - leftHeight;
		if (abs(diff) > 1)
		{
			cout << "高度差出现问题" << endl;
			return false;
		}
		if (diff != root->bf)
		{
			cout << "平衡因子出现问题" << endl;
			return false;
		}
		return IsBalance(root->left) && IsBalance(root->right);
	}
	bool find(T key)
	{
		Node* pcur = _root;
		while (pcur)
		{
			if (pcur->_key < key)
			{
				pcur = pcur->right;
			}
			else if (pcur->_key > key)
			{
				pcur = pcur->left;
			}
			else
				return true;
		}
		return false;
	}
	bool insert(const T& key)
	{
		if (_root == nullptr)//空树的情况
		{
			_root = new Node(key);
			return true;
		}
		Node* pcur = _root;
		Node* pre = nullptr;
		while (pcur)//插入树里面不存在的值，pcur一定会走向空
		{
			pre = pcur;//插入位置的父节点
			if (pcur->_key < key)
			{
				pcur = pcur->right;
			}
			else if (pcur->_key > key)
			{
				pcur = pcur->left;
			}
			else//插入的值已存在，无需插入
			{
				return false;
			}
		}
		pcur = new Node(key);//作为插入的新结点
		if (pre->_key < key)
			pre->right = pcur;
		else 
			pre->left = pcur;
		pcur->parent = pre;//链接父子结点
		// 插入完成后更新并检查平衡因子，不满足平衡条件的，旋转
		while (pre)
		{
			//更新平衡因子
			if(pre->right == pcur)
				++pre->bf;//插在右子树平衡因子+1
			if(pre->left == pcur)
				--pre->bf;//插在左子树平衡因子 -1
			//更新后检查平衡因子
			if (pre->bf == 0)
				break;
			else if (pre->bf == -1 || pre->bf == 1)//插入前平衡因子是0，插入后改变了树的高度
			{
				pcur = pre;//pcur=pcur->parent
				pre = pre->parent;//向上继续判断
			}
			else if (pre->bf == 2 || pre->bf == -2)//插入前平衡因子不是1就是-1
			{
				//旋转处理
				if (pre->bf == -2 && pcur->bf == -1)//左子树高
					RotateR(pre);
				else if(pre->bf == 2 && pcur->bf == 1)//右子树高
					RotateL(pre);
				else if (pre->bf == -2 && pcur->bf == 1)//左子树高但是插在subL的右子树上
				{
					RotateLR(pre);
				}
				else if (pre->bf == 2 && pcur->bf == -1)//右子树高但是插在subR的左子树上
				{
					RotateRL(pre);
				}
				break;//此时要跳出循环，(因为旋转后，原来根结点的位置发生改变，且此时平衡因子出现问题的那棵子树达到平衡），不然会出问题（因为这个调试了半天）
			}
			else
				assert(false);//平衡因子绝对值大于2说明旋转操作有问题，此时断言错误
		}
		return true;
	}
private:
	//右单旋（左子树高）此时插入结点的位置是subL的左子树上
	void RotateR(Node* root)
	{
		Node* subL = root->left;//左子树的根结点
		Node* subLR = subL->right;
		root->left = subLR;
		if (subLR)//不为空则链接
		{
			subLR->parent = root;
		}
		subL->right = root;
		if (root->parent == nullptr)//整个二叉树的根结点出现问题
		{
			_root = subL;//更新根结点
		}
		else//更换了子树根的位置，需要重新链接，避免出现4插链的情况
		{
			if (root == root->parent->left)
				root->parent->left = subL;
			if(root == root->parent->right)
				root->parent->right = subL;
		}
		subL->parent = root->parent;
		root->parent = subL;
		//更新平衡因子
		subL->bf = 0;
		root->bf = 0;
	}
	//左单旋（右子树高）此时插入结点的位置是subR的右子树上
	void RotateL(Node* root)
	{
		Node* subR = root->right;
		Node* subRL = subR->left;
		root->right = subRL;
		if (subRL)//不为空
		{
			subRL->parent = root;
		}
		subR->left = root;
		if (root->parent == nullptr)//整个二叉树的根结点出现问题
		{
			_root = subR;//更新根结点
		}
		else//更换了子树根的位置，需要重新链接，避免出现4插链的情况
		{
			if (root == root->parent->left)
				root->parent->left = subR;
			if (root == root->parent->right)
				root->parent->right = subR;
		}
		subR->parent = root->parent;
		root->parent = subR;
		//更新平衡因子
		root->bf = 0;
		subR->bf = 0;
	}
	//左旋+右旋（左子树高但是插在subL的右子树上）
	void RotateLR(Node* root)
	{
		Node* subL = root->left;
		Node* subLR = subL->right;
		int bf = subLR->bf;//记录，用于判断更新情况
		RotateL(subL);
		RotateR(root);
		if (bf == 0)
		{
			root->bf = 0;
			subL->bf = 0;
			subLR->bf = 0;
		}
		else if (bf == -1)
		{
			root->bf = 1;
			subL->bf = 0;
			subLR->bf = 0;
		}
		else if (bf == 1)
		{
			root->bf = 0;
			subL->bf = 0;
			subLR->bf = 1;
		}
		else
			assert(false);
	}
	//右旋+左旋（右子树高但是插在subR的左子树上）
	void RotateRL(Node* root)
	{
		Node* subR = root->right;
		Node* subRL = subR->left;
		int bf = subRL->bf;
		RotateR(subR);
		RotateL(root);
		if (bf == 0)
		{
			subR->bf = 0;
			subRL->bf = 0;
			root->bf = 0;
		}
		else if (bf == 1)
		{
			subR->bf = 0;
			subRL->bf = 0;
			root->bf = -1;
		}
		else if (bf == -1)
		{
			subR->bf = 1;
			subRL->bf = 0;
			root->bf = 0;
		}
		else
			assert(false);
	}
	void _InOrder(Node* root)//中序遍历
	{
		if (root == nullptr)
			return;
		_InOrder(root->left);
		cout << root->_key << " ";
		_InOrder(root->right);
	}
	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftH = _Height(root->left);
		int rightH = _Height(root->right);
		return leftH > rightH ? leftH + 1 : rightH + 1;
	}
	void Destroy(Node* root)//逐一销毁结点
	{//后续删除
		if (root == nullptr)
			return;
		Destroy(root->left);
		Destroy(root->right);
		delete root;
	}
	Node* _root=nullptr;
};

四、AVL树的性能

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

crystal dell
关注
数据结构（中）-二叉树及AVL树
waner_jiaki的博客
01-18 479
二叉树 之前介绍的数组、链表、栈、队列 都是线性结构。 二叉树为树形结构 一棵树可以没有任何节点，称为空树。 一棵树可以只有一个节点，也就只有根节点。 节点的度：子树的个数。 树的度：所有节点中度中的最大值。 叶子节点：（leaf）度为0的节点。 层数：根节点在第一层，根节点的子节点在第二层，以此类推，（有些资料也从第0层开始）。 节点的深度： 从根节点到当前节点的唯一路径上的节点总数。 节点的高度： 从当前节点到最远叶子节点的路径上的节点总数。 树的深度 所有节点深度中的最大值 树的高度：所有节点高度中
树之完全二叉树(AVL树)
GailyYelp的博客
03-22 3237
目录 AVL树的简介 AVL举例以及详细分析 代码块 测试结果和参考图纸 备注 AVL树的简介AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于”二叉查找树”，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。 这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复
平衡二叉树之AVL树
横扫天下的博客
04-24 581
平衡二叉树之AVL树简介 之前有篇文章讲二叉排序树（动态查找二叉排序树 ），二叉排序树是用于动态查找的数据结构，但在文章结尾中也说明了普通的二叉排序树的查找效率是不确定的，这主要取决于二叉排序树是否平衡，为了充分发挥二叉排序树的查找效率我们通常使用平衡的二叉排序树——平衡二叉树，常用的平衡二叉树主要有两种——AVL树和红黑树。今天我们主要介绍AVL树。 简介 AVL树的平衡条件为：其每个节点的左子...
平衡搜索二叉树之AVL树解析
qq_68140277的博客
03-14 687
树这个神奇的结构，由于其带有数学中指数增长的性质，再给予其一些特殊的性质后，被广泛应用于存储和搜索等苦力活，今天我们来学习用来搜索二叉树中的AVL树是如何实现高效的搜索功能的。
平衡二叉树之AVL树的旋转
allen的博客
02-06 1826
平衡二叉树是基于二叉排序树（或者也叫二叉搜索树）实现的一种自平衡的二叉树，实现方法有比如：AVL树、红黑树等等 二叉搜索树定义（维基百科）： 二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意节点的左子
平衡二叉树 之 AVL树
csdn_walter的博客
12-06 266
http://blog.csdn.net/whucyl/article/details/17289841
判断二叉树是否AVL树
EverydayIsLife的博客
03-17 2292
一、算法思想： 递归法判断一个二叉树是否平衡二叉树（AVL树），可以根据它的定义写出代码：（1）空树是一个AVL树；（2）只有一个根结点的树是一个AVL树；（2）左子树是一颗AVL树，且右子树是一个AVL树，且左子树的高度与右子树的高度差绝对值不超过1。 二、代码： /* name: author:followStep description: date:2018/3/1...
平衡二叉树（AVL树）
Xpccccc的博客
03-27 1391
平衡二叉树（AVL树）
5分钟了解二叉树之AVL树.doc
07-12
AVL树是自平衡二叉查找树的一种，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。它是最早被发明的自平衡树，其核心特性是任何节点的左右子树高度差不超过1，确保了树的平衡性，从而提高了查找...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 440
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1136
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 285
试除法求约数、约数个数、约数之和、最大公约数
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1164
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 937
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 460
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 432
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
平衡二叉树与AVL树详解
"这篇内容主要介绍了高级数据结构中的平衡二叉树，特别是AVL树的概念、性质以及旋转操作。" 在计算机科学中，高级数据结构是处理复杂数据组织方式的关键，其中平衡二叉树是一种重要的数据结构，它优化了基本二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值