Cpp || AVL树

最新推荐文章于 2022-11-02 18:34:47 发布
最新推荐文章于 2022-11-02 18:34:47 发布
阅读量351 收藏
点赞数
分类专栏： Cpp进阶学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack_wang128801/article/details/99635148
版权

文章目录

一：AVL树的简介

1.1：AVL树的概念

【问题的显现】
二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序的二叉搜索树将退化为单支树(如下图所示),查找元素相当于在顺序表中搜索元素,效率低下.
在这里插入图片描述
【解决办法–>AVL树的提出】
当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高度,从而减少平均搜索长度.

【注意】
一棵AVL树或者是空树是具有以下性质的二叉搜索树:
它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

【AVL树图示】
在这里插入图片描述

  • 观察上图,可以看出这棵树中平衡因子的大小关系.

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

二：AVL树的插入

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

2.1:按照二叉搜索树的方式插入新节点
bool insert(const T& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}

		pNode cur = _root;
		pNode parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_data > val)
			{
				cur = cur->_pLeft;
			}
			else if (cur->_data < val)
			{
				cur = cur->_pRight;
			}
			else
				return false;
		}

		pNode newNode = new Node(val);
		if (parent->_data > val)
			parent->_pLeft = newNode;
		else
			parent->_pRight = newNode;
		newNode->_pParent = parent;
		cur = newNode;
		//调整，保证平衡
		while (parent)
		{
			//更新当前节点的平衡因子
			if (parent->_pLeft == cur)
				--parent->_bf;
			else
				++parent->_bf;
			//检查平衡因子，_bf ==0, 高度没有发生变化，停止更新
			if (parent->_bf == 0)
				break;
			//高度加1，更新此路径上的祖先节点的平衡因子
			if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_pParent;
			}

			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)
				{
					//左右双旋

					RotateL(cur);
					RotateR(parent);

				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					pNode subR = parent->_pRight;
					pNode subRL = subR->_pLeft;
					int bf = subRL->_bf;
					//右左双旋
					RotateR(cur);
					RotateL(parent);
					if (bf == 1)
					{
						subR->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						parent->_bf = 0;
						subR->_bf = 1;
					}
				}

				//旋转结束，已经平衡，结束调整
				break;
			}
		}
		return true;
	}

【总结】

  • 1.先按照二叉搜索树的规则将节点插入到AVL树中
  • 2.新节点插入后，AVL树的平衡性可能会遭到破坏,此时就需要更新平衡因子,并检测是否破坏了AVL树的平衡性

pCur插入后,pParent的平衡因子一定需要调整,在插入之前,pParent
的平衡因子分为三种情况:-1,0, 1, 分以下两种情况:

  • 1.如果pCur插入到pParent的左侧,只需给pParent的平衡因子-1即可
  • 2.如果pCur插入到pParent的右侧,只需给pParent的平衡因子+1即可

此时:pParent的平衡因子可能有三种情况:0,正负1,正负2

  • 1.如果pParent的平衡因子为0,说明插入之前pParent的平衡因子为正负1,插入后被调整成0,此时满足AVL树的性质,插入成功
  • 2.如果pParent的平衡因子为正负1,说明插入前pParent的平衡因子一定为0,插入后被更新成正负1,此时以pParent为根的树的高度增加,需要继续向上更新
  • 3.如果pParent的平衡因子为正负2,则pParent的平衡因子违反平衡树的性质,需要对其进行旋转处理
2.2:AVL树的旋转
2.2.1:左旋
2.2.1:虚拟状态

  • AVL树原始图
    在这里插入图片描述
    其中的a,b,c表示的是子树,其树的高度是h

  • 现往c子树中插入某个新的结点后
    在这里插入图片描述

  • 调整完成后在这里插入图片描述

2.2.2:实例
  • 按照代码进行调整的过程
    在这里插入图片描述
2.2.3:代码实现
  • 左旋条件:parent->_bf== 2 && cur->_bf==1
void RotateL(pNode parent)
    {
      pNode subR = parent->_pRight;
      pNode subRL = subR->_pLeft;
      //旋转
      subR->_pLeft = parent;
      parent->_pRight = subRL;

      //更新三叉链
      //链接subRL 和parent
      if (subRL)
        subRL->_pParent = parent;

      //链接subR 和 parent->_pParent
      if (parent != _root)
      {
        pNode gParent = parent->_pParent;
        //判断parent之前是parent->_pParent的那一边的节点
        //把subR链接到对应的边

        if (gParent->_pLeft == parent)
          gParent->_pLeft = subR;
        else
          gParent->_pRight = subR;
        //更新subR的pParent
        subR->_pParent = gParent;
      }
      else
      {
        //如果parent是根，subR变成新的根
        subR->_pParent = nullptr;
        _root = subR;
      }

      //链接subR 和 parent
      parent->_pParent = subR;

      //更新平衡因子
      subR->_bf = parent->_bf = 0;
    }
2.3:右旋
2.3.1:虚拟状态

在这里插入图片描述

2.3.2:实例

在这里插入图片描述

2.3.3:代码实现
void RotateR(pNode parent)
    {
      pNode subL = parent->_pLeft;
      pNode subLR = subL->_pRight;
      // 1. 单向链接subL, subLR, parent
      subL->_pRight = parent;
      parent->_pLeft = subLR;
      //2 向上链接subLR, parent
      if (subLR)
        subLR->_pParent = parent;
      //3. 双向链接subL与pParent->_pParent
      if (parent != _root)
      {
        pNode gParent = parent->_pParent;
        if (gParent->_pLeft == parent)
          gParent->_pLeft = subL;
        else
          gParent->_pRight = subL;
        subL->_pParent = gParent;
      }
      else
      {
        subL->_pParent = nullptr;
        _root = subL;
        //更新根节点
      }
      //4. 向上链接parent, subL
      parent->_pParent = subL;
      //更新平衡因子
      parent->_bf = subL->_bf = 0;

    }
2.4:左右旋:先左旋再右旋
2.4.1:左右旋转图视

在这里插入图片描述

  • 分析
  • 1.在上图中值为60的结点的左子树中插入了一个新的结点
  • 2.先完成一次左单旋
  • 3.再完成一次右单旋
  • 实例(两种不同的插入方式平衡因子的变动)
    在这里插入图片描述
2.4.1:实现代码
  • 条件:parent->_bf== 2 && cur->_bf==-1
if (parent->_bf == -2 && cur->_bf == 1)
{
          pNode subL=parent->_left;                    
            pNode subLR=subL->_right;
            int bf=subLR->_bf;
            RotateL(cur);
            RotateR(parent);
 
            if(bf==1){
              parent->_bf=0;
              subL->_bf=-1;
            }else if(bf==-1){
              parent->_bf=1;
              subL->_bf=0;
            }
  }
2.5:右左旋:先右旋,再左旋
2.5.1:右左旋图视

在这里插入图片描述

  • 分析
  • 1.在60的右子树中插入了一个新的结点
  • 2.先完成一次右单旋
  • 3.再完成一次左单旋
  • 实例(两种不同插入方式,导致的平衡因子的改变)
    在这里插入图片描述
2.5.2:代码实现
  • 条件:parent->_bf== 2 && sub->_bf ==-1
if (parent->_bf == 2 && cur->_bf == -1)
{
	pNode subR = parent->_pRight;
	pNode subRL = subR->_pLeft;
	int bf = subRL->_bf;
	//右左双旋
	RotateR(cur);
	RotateL(parent);
		if (bf == 1)
		{
			subR->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			parent->_bf = 0;
			subR->_bf = 1;
		}
}
三:实现AVL树
#include <iostream>

using namespace std;

template<class T>
//AVL树结点的定义
struct AVLNode
{
	AVLNode(const T& val = T())
	:_data(val)
	, _pLeft(nullptr)
	, _pRight(nullptr)
	, _pParent(nullptr)
	, _bf(0)
	{}
	T _data;
	AVLNode<T>* _pLeft;    //指向该节点的左孩子
	AVLNode<T>* _pRight;  //指向该节点的右孩子
	AVLNode<T>* _pParent; //指向该节点的双亲结点
	//平衡因子
	int _bf;
};

template <class T>
class AVLTree
{
public:
	typedef AVLNode<T> Node;
	typedef Node* pNode;

	bool insert(const T& val)
	{
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}

		pNode cur = _root;
		pNode parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_data > val)
			{
				cur = cur->_pLeft;
			}
			else if (cur->_data < val)
			{
				cur = cur->_pRight;
			}
			else
				return false;
		}

		pNode newNode = new Node(val);
		if (parent->_data > val)
			parent->_pLeft = newNode;
		else
			parent->_pRight = newNode;
		newNode->_pParent = parent;
		cur = newNode;
		//调整，保证平衡
		while (parent)
		{
			//更新当前节点的平衡因子
			if (parent->_pLeft == cur)
				--parent->_bf;
			else
				++parent->_bf;
			//检查平衡因子，_bf ==0, 高度没有发生变化，停止更新
			if (parent->_bf == 0)
				break;
			//高度加1，更新此路径上的祖先节点的平衡因子
			if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_pParent;
			}

			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)
				{
					//左右双旋
            pNode subL=parent->_left;                    
            pNode subLR=subL->_right;
            int bf=subLR->_bf;
            RotateL(cur);
            RotateR(parent);
 
            if(bf==1){
              parent->_bf=0;
              subL->_bf=-1;
            }else if(bf==-1){
              parent->_bf=1;
              subL->_bf=0;
            }
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					pNode subR = parent->_pRight;
					pNode subRL = subR->_pLeft;
					int bf = subRL->_bf;
					//右左双旋
					RotateR(cur);
					RotateL(parent);
					if (bf == 1)
					{
						subR->_bf = 0;
						parent->_bf = -1;
					}
					else if (bf == -1)
					{
						parent->_bf = 0;
						subR->_bf = 1;
					}
				}

				//旋转结束，已经平衡，结束调整
				break;
			}
		}
		return true;
	}

	void RotateL(pNode parent)
	{
		pNode subR = parent->_pRight;
		pNode subRL = subR->_pLeft;
		//旋转
		subR->_pLeft = parent;
		parent->_pRight = subRL;

		//更新三叉链
		//链接subRL 和parent
		if (subRL)
			subRL->_pParent = parent;

		//链接subR 和 parent->_pParent
		if (parent != _root)
		{
			pNode gParent = parent->_pParent;
			//判断parent之前是parent->_pParent的那一边的节点
			//把subR链接到对应的边

			if (gParent->_pLeft == parent)
				gParent->_pLeft = subR;
			else
				gParent->_pRight = subR;
			//更新subR的pParent
			subR->_pParent = gParent;
		}
		else
		{
			//如果parent是根，subR变成新的根
			subR->_pParent = nullptr;
			_root = subR;
		}

		//链接subR 和 parent
		parent->_pParent = subR;

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


	//右旋
	void RotateR(pNode parent)
	{
		pNode subL = parent->_pLeft;
		pNode subLR = subL->_pRight;
		// 1. 单向链接subL, subLR, parent
		subL->_pRight = parent;
		parent->_pLeft = subLR;
		//2 向上链接subLR, parent
		if (subLR)
			subLR->_pParent = parent;
		//3. 双向链接subL与pParent->_pParent
		if (parent != _root)
		{
			pNode gParent = parent->_pParent;
			if (gParent->_pLeft == parent)
				gParent->_pLeft = subL;
			else
				gParent->_pRight = subL;
			subL->_pParent = gParent;
		}
		else
		{
			subL->_pParent = nullptr;
			_root = subL;
			//更新根节点
		}
		//4. 向上链接parent, subL
		parent->_pParent = subL;
		//更新平衡因子
		parent->_bf = subL->_bf = 0;

	}

	/*
	左右双旋的条件：parent->bf==-2;孩子结点bf==1;
	先左旋，后右旋
	左旋:RotateL(subL)
	右旋:RotateR(parent)
	*/

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

	void _Inorder(pNode root)
	{
		if (root)
		{
			_Inorder(root->_pLeft);
			cout << root->_data << " ";
			_Inorder(root->_pRight);
		}
	}

	int Height(pNode cur)
	{
		if (cur == nullptr)
			return 0;
		int left = Height(cur->_pLeft);
		int right = Height(cur->_pRight);
		return left > right ? left + 1 : right + 1;
	}

	bool IsBalance()
	{
		return _isBalance(_root);
	}

	bool _isBalance(pNode root)
	{
		if (root == nullptr)
			return true;
		int left = Height(root->_pLeft);
		int right = Height(root->_pRight);

		if (root->_bf != (right - left))
		{
			cout << root->_data << "--->" << root->_bf << "  " << (right - left) << endl;
			return false;
		}


		return abs(root->_bf) < 2 && _isBalance(root->_pLeft)
			&& _isBalance(root->_pRight);
	}

private:
	pNode _root = nullptr;
};

void testAVL()
{
	
	int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

	AVLTree<int> avl;
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		avl.insert(arr[i]);
		cout << "插入值:"<<arr[i] << "--->" << "平衡因子:"<<avl.IsBalance() << endl;
	}
	avl.Inorder();
}

int main()
{
	testAVL();
	return 0;
}
iTXCode
关注
专栏目录
AVL树的实现（C++)
King_DJF的博客
10-22 815
Implement of AVL_Tree using CppImplement of AVL_Tree using Cpp
C++模板实现的AVL树
eskimoer的专栏
11-03 3335
1 AVL树的定义 AVL树是一种自平衡二叉排序树，它的特点是任何一个节点的左子树高度和右子树的高度差在-1,0,1三者之间。AVL树的任何一个子树都是AVL树。 2 AVL树的实现 AVL树本质是一种二叉排序树，所以二叉排序树的任何性质AVL树都具有，但是AVL树稍微复杂的地方就是AVL树必须满足平衡条件，具体跟BST不同的地方主要体现在插入，删除操作。 插入操作：当插入之后可能会出现不
_cpp AVL树(map、set等关联式容器的底层结构)
Dingyuan0的博客
11-02 725
0. 前言 1. AVL树的概念 2. AVL树节点的定义 3. AVL树的插入 4. AVL树的旋转 4.1 新节点插入较高右子树的右侧---右右：左单旋 4.2 新节点插入较高左子树的左侧---左左：右单旋 4.3.新节点插入较高左子树的右侧---左右：先左单旋再右单旋 4.4 新节点插入较高右子树的左侧---右左：先右单旋再左单旋 5. AVL树的验证 6. 本篇总代码
AVL树的C++实现
kenby的专栏
06-08 4789
包括3个文件:AvlNode.h    AvlTree.h和main.cpp1.节点类的定义AvlNode.h#ifndef AVLNODE_H#define AVLNODE_H#include using namespace std;template  class AvlTree; //声明AvlTree类template class AvlNode{public:       frien
AVL树的详细实现(C++)
code_peak
10-05 4941
AVL树概念 前面已经介绍了二叉搜索树，但是二叉搜索树在某些情况下会出现极度不平衡，其树形结构便退化成了链表，查找效率也会下降。于是出现了 AVL 树，AVL 树保证了二叉搜索树的平衡，引入了平衡监督机制，也就是在插入结点时，树中某一部分不平衡度超过一个阈值后将出发平衡调整操作，这样便保证了树的平衡度在可接受的范围内，最大的好处就是提高了搜索的效率。 AVL 树是一种平衡二叉树，其名字来源于发明者的名字（Adelson-Velskii 以及 Landis）。AVL树的递归定义如下： 左右子树的高度差小于等
cpp-AVL树能一直保持平衡的二叉搜索树
08-16
AVL树,能一直保持平衡的二叉搜索树
avl.rar_AVL树_avl 旋转_树 旋转
09-24
在"avl.rar"压缩包中的"main.cpp"文件，很可能是实现了一个AVL树的C++程序，包括查找、删除以及上述四种旋转操作的代码。通过直接运行这个程序，我们可以观察和理解AVL树的各种操作是如何在实际中执行的。查找操作...
AVL_tree.zip_AVL树_avl_tree_avl树左右子树_平衡树_高度平衡树
09-21
AVL树的实现通常用C++或其他编程语言完成，如提供的"AVL_tree.cpp"文件可能包含了AVL树的结构定义、插入、删除和旋转等操作的实现。在实际应用中，AVL树常用于数据库索引、文件系统、编译器符号表等场景，因为它保证...
AVL.rar_AVL树
09-21
在`AVL.cpp`这个文件中，可能包含了实现AVL树操作的C++代码，包括节点结构定义、插入、删除、旋转等函数。通过阅读和理解这段代码，可以深入学习AVL树的原理和具体实现细节。对于学习数据结构和算法的开发者来说，这...
AVLTree.cpp
03-08
AVLTree（平衡二叉树）是常用的数据结构，文件中包括该数据结构的实现、基于该数据结构的算法详细分析，下载可直接运行调试，可供数据结构与算法课程的学习
leetcode-cpp 219.存在重复元素II
weixin_43255713的博客
04-14 175
219.存在重复元素II 题目： 链接 leetcode solution: 用unordered_map，其中key值为nums[i]，value值为下标，如果map中还没有该元素，则增加，否则比较找的元素下标与当前下标的差绝对值是否大于k code class Solution { public: bool containsNearbyDuplicate(v...
AVLTree的实现C++
C++
02-22 317
普通的binary Search Tree的大量插入删除操作会造成树的不平衡，使得查找等操作效率不再为O(logn)。 AVLTree能够保证插入，删除，查找等操作在O(logn)内完成。 组成AVLTree的最少节点数与斐波那契数列的关系。 AVLTree的插入操作完成插入后需要更新节点的高度信息，并重新平衡此树， 找到发现问题的节点（imbalance factor == 2），并平衡以...
【算法学习】AVL平衡二叉搜索树原理及各项操作编程实现（C++）
热门推荐
计算机专业同学的充电站。
12-13 1万+
AVLTree即（Adelson-Velskii-Landis Tree），是加了额外条件的二叉搜索树。其平衡条件的建立是为了确保整棵树的深度为O(nLogn)。平衡条件是任何节点的左右子树的高度相差不超过1. 在下面的代码中，编程实现了AVL树的建立、查找、插入、删除、遍历等操作。采用C++类封装。 AVL树中比较复杂的操作时插入和删除操作。在这里对插入和删除操作进行讲解。
平衡搜索树-AVLTree的简单实现
婉茹的博客
11-12 322
1.什么是AVL树     AVL树又称为高度平衡的二叉搜索树，它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度（近似完全二叉树）。 2.为什么叫AVL树呢？      应该是因为它是由俄罗斯数学家G.M.Adel'son-Vel'skii和E.M.Landis在1962年提出来的，所以以他们的名字命名了平衡搜索树。^*^ 3.AVL树的性质： （1）左子树和
使用C++实现AVL树模板
FS's Home
12-13 6008
今天练习编写了一下AVL树。参考了Weiss的数据结构与算法C++描述版。上一个实现的一个一般的二叉搜索树，在使用的过程中可能会慢慢变得不平衡，这样很可能会降低查找、插入等等的效率，因此我们需要使用算法来实现树的平衡。AVL树是一种比较经典的平衡二叉搜索树，它规定每个节点的左子树和右子树的高度差最多为1，默认空树的高度为-1，这样能保证树的深度为O(logN)，而且除了遍历，赋值，基本上所有树的操作都可以以时间O(logN)执行（当然插入和删除后因为要重新平衡树，可能时间会长于O(logN)）。（Ps，上面
AVL树简单构建和基本使用（C++)
Cute_jinx的博客
09-02 625
AVL树的原理挺复杂的，推荐一个博客，原理写得非常详细。 https://blog.csdn.net/howardemily/article/details/79543892 在这我就直接上 简化版的AVL代码吧, 希望对后来者有用。 对于LL AVLtree* opLL() { AVLtree* pa = this, *pb = left, *pc = ((left)-&gt...
【c++】AVL树详解
LLZK_的博客
10-30 2272
AVL树是又叫平衡二叉搜索树，但是它不是完全平衡，只是近似平衡（高度平衡）。什么叫完全平衡？想象一下完全二叉树。 根据名字’二叉搜索树‘，我们可以知道它的一些性质： 1. 每个节点都有一个作为搜索依据的关键码（key），所有节点的关键码互不相同。 2. 左子树上所有节点的关键码（key）都小于根节点的关键码（key）。 3. 右子树上所有节点的关键码（key）都大于根节点的关键码（key）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值