C++ -- AVL树插入实现和测试

最新推荐文章于 2024-05-20 19:57:12 发布
最新推荐文章于 2024-05-20 19:57:12 发布
阅读量401 收藏 5
点赞数 5
分类专栏： c++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46343224/article/details/130677794
版权
文章详细介绍了AVL树的概念，包括其自平衡性质、节点结构、插入操作以及插入后的平衡更新。通过插入节点，更新平衡因子，并在需要时进行左单旋、右单旋、先左后右旋、先右后左旋四种旋转操作以保持树的平衡。同时，提供了中序遍历和检查树是否平衡的方法。
摘要由CSDN通过智能技术生成

文章目录

1. AVL树概念

AVL树就是自平衡二叉查找树，为了解决二叉树退化为单链表，使得增删查改时间度为O(N)，这里采用控制平衡策略达到效率是O(logN)。

2. AVL树满足性质

  • 每个节点的左右子树高度之差绝对不能超过1
    • 左边插入（父节点高度差-1）
    • 右边插入（父节点高度差+1）
    • 不插入（自身节点高度差为0）

3. AVL节点结构

template <class KEY, class VAULE>
struct AVLtree_node
{
	AVLtree_node<KEY, VAULE>* _left; //左节点指向
	AVLtree_node<KEY, VAULE>* _right; //右节点指向
	AVLtree_node<KEY, VAULE>* _parent; //父节点指向

	pair<KEY, VAULE> _couple; //存储key/value
	int _balanceFactor; //平衡因子(左右子树高度差)

	AVLtree_node(const pair<KEY, VAULE>& couple)
		:_left(nullptr)
		:_right(nullptr)
		:_parent(nullptr)
		:_couple(couple)
		:_balanceFactor(0)
	{}
};

4. 插入操作

  1. 插入阶段
    1. 根节点为空
      1. new节点，改变根指向，返回true
    2. 根节点不为空
      1. 找到插入位置
        1. 右查找：当前节点key值 < 插入节点key值
        2. 左查找：当前节点key值 > 插入节点key值
        3. 当前节点key值 = 插入节点key值 ：直接返回false
      2. 在对应待插入位置插入
        1. new节点，当前插入位置指向该节点
        2. 右插入：当前节点key值 < 插入节点key值
        3. 左插入: 当前节点key值 > 插入节点key值
      3. 当前被插入节点父指针指向指向被连接节点
      4. 自动平衡（TODO）
bool insert(const pair<KEY, VAULE>& couple)
{
    //二叉搜索树阶段
	if (_root == nullptr) //根为空:直接new并指向返回
	{
		_root = new node(couple);
		return true;
	}

	/*找插入位置*/
	node* parent = nullptr; //起初根节点的父节点为nullptr
	node* cur = _root; //被插入节点指向
	while (cur)
	{
		if (cur->_couple.first < couple.first) //右查找：当前节点key值 < 插入节点key值
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_couple.first > couple.first) //左查找: 当前节点key值 > 插入节点key值
		{
			parent = cur;
			cur = cur->_left;
		}
		else //当前节点key值 = 插入节点key值：直接退出
		{
			return false;
		}
	}

	/*在对应位置插入*/
	cur = new node(couple);
	if (parent->_couple.first > couple.first) //左插入: 当前节点key值 > 插入节点key值
	{
		parent->_left = newnode;
	}
	else //右插入：当前节点key值 < 插入节点key值
	{
		parent->_right = newnode;
	}
	cur->_parent = parent; //反向链接

	/*自动平衡 TODO*/
    //AVL树阶段

}
  1. 平衡阶段铺垫

注意：并没有画上父节点指向，为了便于观察所以没有画，默认每个节点是有父节点指向的

  • 右边插入构图
  • 左边插入构图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rGLjZnpU-1684114665514)(https://typora130.oss-cn-nanjing.aliyuncs.com/QQ截图20230513154519.png)]

上面左右插入构图示范中，观察发现该节点左右子树高度差超过了1就会形成子树单链表，这样就会影响到效率，那么这里的解决办法就是对其旋转处理（待解），另外观察到上面错误高度差情况，会发现一旦插入其被插入节点的部分祖先的平衡因子（高度差）可能改变，所以，插入新增节点会影响部分或全部祖先的平衡因子，平衡因子怎么来更新呢？如果新增节点在其父节点左边，父节点平衡因子-1，如果新增节点在其父节点右边，父节点平衡因子+1，每个节点的平衡因子初始状态都是0。是什么时候平衡因子更新？当插入节点的父节点的平衡因子变化（不为0），那么就需要对其被插入节点的部分或者全部祖先的平衡因子更新。

观察：右边插入三种情况示范：

被插入节点父节点平衡高度不为0，就向上更新祖先的平衡因子，向上更新的依据是该节点左右子树高度变化了；如果插入节点父节点平衡高度为0，就无需向上更新平衡因子

后面两种情况观察：当祖先节点的平衡因子为2或者-2时，就不应该再往上层更新平衡因子了（key值为7的节点的平衡因子就没必要更新了），因为此时只要有一个祖先的平衡因子为2说明就已经有问题了，就需要对这部分子树来调整达到一种平衡状态（旋转处理）。

  1. 自动平衡
    1. 更新平衡因子
      1. 改变被插入节点父节点平衡因子
        1. 被插入节点在其父节点右子树中：父节点平衡因子+1
        2. 被插入节点在其父节点左子树中：父节点平衡因子-1
      2. 判断是否继续向上更新平衡因子
        1. 父节点平衡因子为1或者-1，继续更新
        2. 父节点平衡因子为0，无需更新
        3. 父节点平衡因子为2或者-2，子树不平衡，旋转处理使得平衡（TODO）
bool insert(const pair<KEY, VAULE>& couple)
{
	if (_root == nullptr) //根为空:直接new并指向返回
	{
		_root = new node(couple);
		return true;
	}

	/*找插入位置*/
	node* parent = nullptr; //起初根节点的父节点为nullptr
	node* cur = _root; //被插入节点指向
	while (cur)
	{
		if (cur->_couple.first < couple.first) //右查找：当前节点key值 < 插入节点key值
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_couple.first > couple.first) //左查找: 当前节点key值 > 插入节点key值
		{
			parent = cur;
			cur = cur->_left;
		}
		else //当前节点key值 = 插入节点key值：直接退出
		{
			return false;
		}
	}

	/*在对应位置插入*/
	cur = new node(couple);
	if (parent->_couple.first > couple.first) //左插入: 当前节点key值 > 插入节点key值
	{
		parent->_left = newnode;
	}
	else //右插入：当前节点key值 < 插入节点key值
	{
		parent->_right = newnode;
	}
	cur->_parent = parent; //反向链接

	/*自动平衡 TODO*/

	//更新平衡因子
	while (parent)
	{
		if (cur == parent->_right) //被插入节点在其父节点右子树中
		{
			parent->_balanceFactor++;
		}
		else //被插入节点在其父节点左子树中
		{
			parent->_balanceFactor--;
		}

		if (parent->_balanceFactor == 1 || parent->_balanceFactor == -1) //继续更新平衡因子
		{
			parent = parent->_parent;
			cur = cur->_parent;
		}
		else if (parent->_balanceFactor == 0) //无需更新
		{
			break;
		}
		else if (parent->_balanceFactor == 2 || parent->_balanceFactor == -2) //子树不平衡(旋转处理)
		{
			/*TODO*/
            
            break; //旋转之后达到平衡无需更新平衡因子(操作完后便知)
		}
		else
		{
			assert(false);
		}
	}
}
  1. 平衡阶段旋转处理

旋转目的：让子树平衡并且降低子树高度

  • 左单旋

左单旋一定是右高左低

三个举例：

三个举例来抽象得到宏观图：

H为这颗子树高度，当H为0，反应就是上述第一个例子；当H为1，反应就是上述第二个例子；当H为2，反应就是上述第三个例子。当H为x时，其调整方法不变。当H为2时，此时有三种情况的高度为2的树：

但是这里c这棵子树必须是x类型的高度为2的树，a,b这两课子树可以是任意一种都可以。为什么c子树必须是x类型的树呢？如果是y型可能插入不会引发旋转，也可能只会局部旋转：

如何旋转？

  1. 让cur的左子树(curLeft)放在parent的右子树位置并且curLeft的父节点指向指向parent
  2. 让parent放在cur的左子树位置并且parent的父节点指向指向cur
  3. cur变为子树或者整颗树的根
  4. 更新parent和cur的平衡因子
//parent->_balanceFactor == 2 && cur->_balanceFactor = 1
void leftSingleRotate(node* parent) //左单旋
{
	//记录指针
	node* parent_RightChild = parent->_right; //parent_RightChild = cur
	node* parent_RightChild_LeftChild = parentRightChild->_left; //parent_RightChild_LeftChild = curLeft
	node* parent_parent = parent->_parent; //局部根或整棵树根的父节点

	parent->_right = parent_RightChild_LeftChild; //让cur的左子树(curLeft)放在parent的右子树位置
	if (parent_RightChild_LeftChild != nullptr) //H为0时,parent_RightChild_LeftChild=nullptr
	{
		parent_RightChild_LeftChild->_parent = parent; //curLeft的父节点指向指向parent
	}
	parent_RightChild->_left = parent; //让parent放在cur的左子树位置
	parent->_parent = parent_RightChild; //parent的父节点指向指向cur

	//cur(parent_RightChild)变为子树或者整颗树的根
	if (parent_parent == nullptr) //parent是整颗树的根
	{
		_root = parent_RightChild;
		_root->_parent = nullptr;
	}
	else //parent是局部子树的根
	{
		if (parent_parent->_left == parent) //parent节点在父节点的左子树位置
		{
			parent_parent->_left = parent_RightChild;
		}
		else //parent节点在父节点的右子树位置
		{
			parent_parent->_right = parent_RightChild;
		}
		parent_RightChild->_parent = parent_parent;
	}

	//更新平衡因子
	parent->_balanceFactor = parent_RightChild->_balanceFactor = 0;
}
  • 右单旋

右单旋一定是左高右低

三个举例来抽象得到宏观图：

H为这颗子树高度，当H为0，反应就是上述第一个例子；当H为1，反应就是上述第二个例子；当H为2，反应就是上述第三个例子。当H为x时，其调整方法不变。当H为2时，这里的c子树必须是x类型的树，此时有三种情况的高度为2的树：

如何旋转？

  1. 让cur的右子树(curRight)放在parent的左子树位置并且让curRight父节点的指向指向parent
  2. 让parent放在cur的右子树位置并且让parent的父节点指向指向cur
  3. cur变为子树或者整颗树的根
  4. 更新parent和cur的平衡因子
//parent->_balanceFactor == -2 && cur->_balanceFactor == -1
void rightSingleRotate(node* parent) //右单旋
{
    //记录指针
    node* parent_LeftChild = parent->_left; //parent_LeftChild = cur
    node* parent_LeftChild_RightChild = parent_LeftChild->_right; //parent_LeftChild_RightChild = curRight
    node* parent_parent = parent->_parent; //局部根或整棵树根的父节点

    parent->_left = parent_LeftChild_RightChild; //让cur的右子树(curRight)放在parent的左子树位置
    if (parent_LeftChild_RightChild != nullptr)
    {
        parent_LeftChild_RightChild->_parent = parent; //让curRight父节点的指向指向parent
    }
    parent_LeftChild->_right = parent; //让parent放在cur的右子树位置
    parent->_parent = parent_LeftChild; //让parent的父节点指向指向cur

    //cur(parent_LeftChild)变为子树或者整颗树的根
    if (parent_parent == nullptr) //parent是整颗树的根
    {
        _root = parent_LeftChild; //cur(parent_LeftChild)就是根
        _root->_parent = nullptr;
    }
    else //parent是局部子树的根
    {
        if (parent_parent->_left == parent) //parent节点在父节点的左子树位置
        {
            parent_parent->_left = parent_LeftChild;
        }
        else //parent节点在父节点的右子树位置
        {
            parent_parent->_right = parent_LeftChild;
        }
        parent_LeftChild->_parent = parent_parent; //cur(parent_LeftChild)指向局部根的父节点
    }

    //更新平衡因子
    parent->_balanceFactor = parent_LeftChild->_balanceFactor = 0;
}
  • 先左后右旋

抽象图：

H为子树高度，H为0时，此时60这个节点也不存在，新增节点必须是key为60这个节点位置；H为1，2，3…等等图形这里不再画出，都可以通过抽象达成相同调整方法，这里被插入节点一定是b，c子树位置或者b，c的子树孩子位置。

如何旋转？

  1. 先左旋cur为根的子树
    1. 让cur的右指向指向curRightLeft并且curRightLeft的父节点的指向指向cur
    2. 让curRight的左指向指向cur并且cur的父节点的指向指向curRight
    3. curRight作为子树根并且改变curRight的父节点的指向指向parent
    4. 更新cur和curRight的平衡因子为0
  2. 后右旋parent为根的子树
    1. 让parent的左指向指向curRightRight并且curRightRight的父节点的指向指向parent
    2. 让curRight的右子树指向parent并且parent的父节点的指向指向curRight
    3. curRight作为树的根并且改变curRight的父节点指向指向空
    4. 更新parent和curRight的平衡因子为0
  3. 更新cur、curRight、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
    1. c子树插入(curRight->_balanceFactor=1)：最终cur的平衡因子为-1，parent平衡因子为0，curRight平衡因子为0
    2. b子树插入(curRight->_balanceFactor=-1)：最终cur的平衡因子为0，parent平衡因子为1，curRight平衡因子为0
    3. curRight本身是被插入节点(curRight->_balanceFactor=0，H=0)，最终cur、parent、curRight平衡因子都为0
//parent->_balanceFactor == -2 && cur->_balanceFactor == 1
void leftRightRotate(node* parent)
{
    node* parent_LeftChild = parent->_left; //parent_LeftChild = cur
    node* parent_LeftChild_RightChild = parent_LeftChild->_right; //parent_LeftChild_RightChild = curRight
    int balanceFactor = parent_LeftChild_RightChild->_balanceFactor; //记录curRight的平衡因子值：确定在b子树还是c子树插入

    leftSingleRotate(parent->_left); //左单旋cur为根树
    rightSingleRotate(parent); //右单旋parent为根的树

    //更新cur、curRight、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
    if (balanceFactor == 1) //c子树插入
    {
        parent->_balanceFactor = 0;
        parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
        parent_LeftChild = -1; //cur->_balanceFactor = -1
    }
    else if (balanceFactor == -1) //b子树插入
    {
        parent->_balanceFactor = 1;
        parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
        parent_LeftChild = 0;  //cur->_balanceFactor = 0
    }
    else if (balanceFactor == 0) //curRight自身是被插入节点
    {
        parent->_balanceFactor = 0;
        parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
        parent_LeftChild = 0;  //cur->_balanceFactor = 0
    }
    else
    {
        assert(false);
    }
}
  • 先右后左旋

抽象图：

H为子树高度，H为0时，此时60这个节点也不存在，新增节点必须是key为60这个节点位置；H为1，2，3…等等图形这里不再画出，都可以通过抽象达成相同调整方法，这里被插入节点一定是b，c子树位置或者b，c的子树孩子位置。

如何旋转？

  1. 先右旋cur为根的子树
    1. 让cur的左指向指向curLeftRight并且curLeftRight的父节点的指向指向cur
    2. 让curLeft的右指向指向cur并且cur的父节点的指向指向curLeft
    3. curLeft作为子树的根并且curLeft的父节点的指向指向parent
    4. 更新cur和curLeft的平衡因子为0
  2. 后左旋parent为根的树
    1. 让parent的右指向指向curLeftLeft并且curLeftLeft的父节点的指向指向parent
    2. 让curLeft的左指向指向parent并且paren的父节点的指向指向curLeft
    3. curLeft作为树的根并且改变curLeft的父节点的指向指向nullptr
    4. 更新parent和curLeft的平衡因子为0
  3. 更新cur、curLeft、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
    1. b子树插入(curLeft->_balance=1)，最终cur的平衡因子为0，parent平衡因子为-1，curLeft平衡因子为0
    2. c子树插入(curLeft->_balance=-1)，最终cur的平衡因子为1，parent平衡因子为0，curLeft平衡因子为0
    3. curLeft本身是被插入节点(curLeft->_balanceFactor=0，H=0)，最终cur、parent、curRight平衡因子都为0
//parent->_balanceFactor == 2 && cur->_balanceFactor == -1
void rightLeftRotate(node* parent) //先右后左旋
{
    node* parent_RightChild = parent->_right; //parent_RightChild = cur
    node* parent_RightChild_LeftChild = parent_RightChild->_left; //parent_RightChild_LeftChild = curLeft
    int balanceFactor = parent_RightChild_LeftChild->_balanceFactor; 记录curLeft的平衡因子值：确定在b子树还是c子树插入

    rightSingleRotate(parent_RightChild); //右单旋cur为根的树
    leftSingleRotate(parent); //左单旋parent为根的树

    //更新cur、curRight、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
    if (balanceFactor == 1) //b子树插入
    {
        parent_RightChild->_balanceFactor = 0; //cur->_balanceFactor = 0
        parent->_balanceFactor = -1;
        parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
    }
    else if (balanceFactor == -1) //c子树插入
    {
        parent_RightChild->_balanceFactor = 1; //cur->_balanceFactor = 1
        parent->_balanceFactor = 0;
        parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
    }
    else if (balanceFactor == 0) //curLeft本身是被插入节点
    {
        parent_RightChild->_balanceFactor = 0; //cur->_balanceFactor = 0
        parent->_balanceFactor = 0;
        parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
    }
    else
    {
        assert(false);
    }
}

5. 检测

  1. 中序遍历是否升序
void inOrder() //中序遍历
{
    _inOrder(_root);
   	cout << endl;
}
void _inOrder(node* root) //中序遍历
{
 	if (root == nullptr)
    {
        return;
    }
    _inOrder(root->_left);
    cout << root->_couple.first << " ";
    _inOrder(root->_right);
}
  1. 是否平衡
bool isBalance() //判断树是否为平衡树
{
    return _isBalance(_root);
}
int heightDiffer(node* root)
{
    if (root == nullptr)
        return 0;
    int leftHeight = heightDiffer(root->_left);
    int rightHeight = heightDiffer(root->_right);

    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; 
}

bool _isBalance(node* root) //判断树是否为平衡树(检查每个节点的左右子树高度差)
{
    if (root == nullptr)
        return true;

    int leftHeight = heightDiffer(root->_left);
    int rightHeight = heightDiffer(root->_right);
    if (rightHeight - leftHeight != root->_balanceFactor) //不只是对高度检查还应该对平衡因子检查
    {
        cout << "key:" << root->_couple.first << " node balanceFactor exception!" << endl;
        return false;
    }

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

6. 完整代码

插入阶段

  1. 根节点为空
    1. new节点，改变根指向，返回true
  2. 根节点不为空
    1. 找到插入位置
      1. 右查找：当前节点key值 < 插入节点key值
      2. 左查找：当前节点key值 > 插入节点key值
      3. 当前节点key值 = 插入节点key值 ：直接返回false
    2. 在对应待插入位置插入
      1. new节点，当前插入位置指向该节点
      2. 右插入：当前节点key值 < 插入节点key值
      3. 左插入: 当前节点key值 > 插入节点key值
    3. 当前被插入节点父指针指向指向被连接节点
    4. 自动平衡
      1. 更新平衡因子
        1. 改变被插入节点父节点平衡因子
          1. 被插入节点在其父节点右子树中：父节点平衡因子+1
          2. 被插入节点在其父节点左子树中：父节点平衡因子-1
        2. 判断是否继续向上更新平衡因子
          1. 父节点平衡因子为1或者-1，继续更新
          2. 父节点平衡因子为0，无需更新
          3. 父节点平衡因子为2或者-2，子树不平衡，旋转处理使得平衡（旋转处理）
            1. parent->_balanceFactor == 2 && cur->_balanceFactor == 1 --> 左单旋
            2. parent->_balanceFactor == -2 && cur->_balanceFactor == -1 --> 右单旋
            3. parent->_balanceFactor == -2 && cur->_balanceFactor == 1 --> 先左后右旋
            4. parent->_balanceFactor == 2 && cur->_balanceFactor == -1 --> 先右后左旋
#pragma once
#include <iostream>
#include <utility>
#include <cassert>
using namespace std;

template <class KEY, class VAULE>
struct AVLtree_node
{
    AVLtree_node<KEY, VAULE>* _left; //左节点指向
    AVLtree_node<KEY, VAULE>* _right; //右节点指向
    AVLtree_node<KEY, VAULE>* _parent; //父节点指向

    pair<KEY, VAULE> _couple; //存储key/value
    int _balanceFactor; //平衡因子(左右子树高度差)

    AVLtree_node(const pair<KEY, VAULE>& couple)
        :_left(nullptr)
        ,_right(nullptr)
        ,_parent(nullptr)
        ,_couple(couple)
        ,_balanceFactor(0)
    {}
};

template <class KEY, class VAULE>
class AVLtree
{
    typedef AVLtree_node<KEY, VAULE> node;
public:
    bool insert(const pair<KEY, VAULE>& couple)
    {
        if (_root == nullptr) //根为空:直接new并指向返回
        {
            _root = new node(couple);
            return true;
        }

        /*找插入位置*/
        node* parent = nullptr; //起初根节点的父节点为nullptr
        node* cur = _root; //被插入节点指向
        while (cur)
        {
            if (cur->_couple.first < couple.first) //右查找：当前节点key值 < 插入节点key值
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_couple.first > couple.first) //左查找: 当前节点key值 > 插入节点key值
            {
                parent = cur;
                cur = cur->_left;
            }
            else //当前节点key值 = 插入节点key值：直接退出
            {
                return false;
            }
        }

        /*在对应位置插入*/
        cur = new node(couple);
        if (parent->_couple.first > couple.first) //左插入: 当前节点key值 > 插入节点key值
        {
            parent->_left = cur;
        }
        else //右插入：当前节点key值 < 插入节点key值
        {
            parent->_right = cur;
        }
        cur->_parent = parent; //反向链接

        /*自动平衡 TODO*/

        //更新平衡因子
        while (parent)
        {
            if (cur == parent->_right) //被插入节点在其父节点右子树中
            {
                parent->_balanceFactor++;
            }
            else //被插入节点在其父节点左子树中
            {
                parent->_balanceFactor--;
            }

            if (parent->_balanceFactor == 1 || parent->_balanceFactor == -1) //继续更新平衡因子
            {
                parent = parent->_parent;
                cur = cur->_parent;
            }
            else if (parent->_balanceFactor == 0)
            {
                break;
            }
            else if (parent->_balanceFactor == 2 || parent->_balanceFactor == -2) //子树不平衡(旋转处理)
            {
                if (parent->_balanceFactor == 2 && cur->_balanceFactor == 1) //左单旋
                {
                    leftSingleRotate(parent);
                }
                else if (parent->_balanceFactor == -2 && cur->_balanceFactor == -1) //右单旋
                {
                    rightSingleRotate(parent);
                }
                else if (parent->_balanceFactor == -2 && cur->_balanceFactor == 1) //先左后右旋
                {
                    leftRightRotate(parent);
                }
                else if (parent->_balanceFactor == 2 && cur->_balanceFactor == -1) //先右后左旋
                {
                    rightLeftRotate(parent);
                }
                else
                {
                    assert(false);
                }

                //旋转可以达到左右子树平衡并且降低高度
                break;
            }
            else
            {
                assert(false);
            }
        }

        return true;
    }

    void inOrder() //中序遍历
    {
        _inOrder(_root);
        cout << endl;
    }

    bool isBalance() //判断树是否为平衡树
    {
        return _isBalance(_root);
    }

private:
    void leftSingleRotate(node* parent) //左单旋
    {
        //记录指针
        node* parent_RightChild = parent->_right; //parent_RightChild = cur
        node* parent_RightChild_LeftChild = parent_RightChild->_left; //parent_RightChild_LeftChild = curLeft
        node* parent_parent = parent->_parent; //局部根或整棵树根的父节点

        parent->_right = parent_RightChild_LeftChild; //让cur的左子树(curLeft)放在parent的右子树位置
        if (parent_RightChild_LeftChild != nullptr) //H为0时,parent_RightChild_LeftChild=nullptr
        {
            parent_RightChild_LeftChild->_parent = parent; //curLeft的父节点指向指向parent
        }
        parent_RightChild->_left = parent; //让parent放在cur的左子树位置
        parent->_parent = parent_RightChild; //parent的父节点指向指向cur
        
        //cur(parent_RightChild)变为子树或者整颗树的根
        if (parent_parent == nullptr) //parent是整颗树的根
        {
            _root = parent_RightChild; //cur(parent_RightChild)就是根
            _root->_parent = nullptr;
        }
        else //parent是局部子树的根
        {
            if (parent_parent->_left == parent) //parent节点在父节点的左子树位置
            {
                parent_parent->_left = parent_RightChild;
            }
            else //parent节点在父节点的右子树位置
            {
                parent_parent->_right = parent_RightChild;
            }
            parent_RightChild->_parent = parent_parent; //cur(parent_RightChild)指向局部根的父节点
        }

        //更新平衡因子
        parent->_balanceFactor = parent_RightChild->_balanceFactor = 0;
    }

    void rightSingleRotate(node* parent) //右单旋
    {
        //记录指针
        node* parent_LeftChild = parent->_left; //parent_LeftChild = cur
        node* parent_LeftChild_RightChild = parent_LeftChild->_right; //parent_LeftChild_RightChild = curRight
        node* parent_parent = parent->_parent; //局部根或整棵树根的父节点

        parent->_left = parent_LeftChild_RightChild; //让cur的右子树(curRight)放在parent的左子树位置
        if (parent_LeftChild_RightChild != nullptr)
        {
            parent_LeftChild_RightChild->_parent = parent; //让curRight父节点的指向指向parent
        }
        parent_LeftChild->_right = parent; //让parent放在cur的右子树位置
        parent->_parent = parent_LeftChild; //让parent的父节点指向指向cur

        //cur(parent_LeftChild)变为子树或者整颗树的根
        if (parent_parent == nullptr) //parent是整颗树的根
        {
            _root = parent_LeftChild; //cur(parent_LeftChild)就是根
            _root->_parent = nullptr;
        }
        else //parent是局部子树的根
        {
            if (parent_parent->_left == parent) //parent节点在父节点的左子树位置
            {
                parent_parent->_left = parent_LeftChild;
            }
            else //parent节点在父节点的右子树位置
            {
                parent_parent->_right = parent_LeftChild;
            }
            parent_LeftChild->_parent = parent_parent; //cur(parent_LeftChild)指向局部根的父节点
        }

        //更新平衡因子
        parent->_balanceFactor = parent_LeftChild->_balanceFactor = 0;
    }

    void leftRightRotate(node* parent) //先左后右旋
    {
        node* parent_LeftChild = parent->_left; //parent_LeftChild = cur
        node* parent_LeftChild_RightChild = parent_LeftChild->_right; //parent_LeftChild_RightChild = curRight
        int balanceFactor = parent_LeftChild_RightChild->_balanceFactor; //记录curRight的平衡因子值：确定在b子树还是c子树插入

        leftSingleRotate(parent->_left); //左单旋cur为根的树
        rightSingleRotate(parent); //右单旋parent为根的树

        //更新cur、curRight、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
        if (balanceFactor == 1) //c子树插入
        {
            parent->_balanceFactor = 0; 
            parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
            parent_LeftChild->_balanceFactor = -1; //cur->_balanceFactor = -1
        }
        else if (balanceFactor == -1) //b子树插入
        {
            parent->_balanceFactor = 1;
            parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
            parent_LeftChild->_balanceFactor = 0;  //cur->_balanceFactor = 0
        }
        else if (balanceFactor == 0) //curRight自身是被插入节点
        {
            parent->_balanceFactor = 0;
            parent_LeftChild_RightChild = 0; //curRight->_balanceFactor = 0
            parent_LeftChild->_balanceFactor = 0;  //cur->_balanceFactor = 0
        }
        else
        {
            assert(false);
        }
    }

    void rightLeftRotate(node* parent) //先右后左旋
    {
        node* parent_RightChild = parent->_right; //parent_RightChild = cur
        node* parent_RightChild_LeftChild = parent_RightChild->_left; //parent_RightChild_LeftChild = curLeft
        int balanceFactor = parent_RightChild_LeftChild->_balanceFactor; 记录curLeft的平衡因子值：确定在b子树还是c子树插入

        rightSingleRotate(parent_RightChild); //右单旋cur为根的树
        leftSingleRotate(parent); //左单旋parent为根的树

        //更新cur、curRight、parent平衡因子（插入b，c子树不同位置会导致最终平衡因子的变化）
        if (balanceFactor == 1) //b子树插入
        {
            parent_RightChild->_balanceFactor = 0; //cur->_balanceFactor = 0
            parent->_balanceFactor = -1;
            parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
        }
        else if (balanceFactor == -1) //c子树插入
        {
            parent_RightChild->_balanceFactor = 1; //cur->_balanceFactor = 1
            parent->_balanceFactor = 0; 
            parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
        }
        else if (balanceFactor == 0) //curLeft本身是被插入节点
        {
            parent_RightChild->_balanceFactor = 0; //cur->_balanceFactor = 0
            parent->_balanceFactor = 0;
            parent_RightChild_LeftChild->_balanceFactor = 0; //curLeft->_balanceFactor = 0;
        }
        else
        {
            assert(false);
        }
    }


    void _inOrder(node* root) //中序遍历
    {
        if (root == nullptr)
        {
            return;
        }
        _inOrder(root->_left);
        cout << root->_couple.first << " ";
        _inOrder(root->_right);
    }

    int heightDiffer(node* root)
    {
        if (root == nullptr)
            return 0;
        int leftHeight = heightDiffer(root->_left);
        int rightHeight = heightDiffer(root->_right);

        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; 
    }

    bool _isBalance(node* root) //判断树是否为平衡树(检查每个节点的左右子树高度差)
    {
        if (root == nullptr)
            return true;

        int leftHeight = heightDiffer(root->_left);
        int rightHeight = heightDiffer(root->_right);
        if (rightHeight - leftHeight != root->_balanceFactor) //不只是对高度检查还应该对平衡因子检查
        {
            cout << "key:" << root->_couple.first << " node balanceFactor exception!" << endl;
            return false;
        }

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


private:
    node* _root = nullptr;
};


/*测试*/
void test_AVLtree1()
{
    //int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14};
    AVLtree<int, int> tree;
    for (auto x : arr)
    {
        tree.insert(make_pair(x, x));
    }

    tree.inOrder(); //中序遍历

    cout << tree.isBalance() << endl; //判断是否为平衡树

}

void test_perfermance() //测试性能
{
    srand(time(nullptr));
    const size_t N = 100000;
    AVLtree<int, int> tree;
    for (size_t i = 0; i < N; ++i)
    {
        size_t x = rand();
        tree.insert(make_pair(x, x));
    }

    cout << tree.isBalance() << endl; 

}
脚踏车(crush)
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
avl树测试代码-经测试可用
03-19
休假期间完成的avl树代码，实现了插入操作，基本演示了avl树生成过程和原理
AVL树测试程序
luyafei_89430的专栏
06-01 1184
AVL树(三) 下面用一个例子来测试AVL树的平衡性 随机的反复插入和删除树中的节点，如代码所示： ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 3
C++|AVL树(模拟实现，测试)
最新发布
weixin_68201503的博客
05-20 800
节点中包括左指针，右指针，指向父节点的指针，平衡因子，要存储的数据值。//节点,_bf(0)T _bf;//平衡因子T _data;//要存储的值。
我的AVL树代码实现（欢迎测试）
roofalison的专栏
03-16 3168
 #include iostream>using namespace std;template typename T>class AVLNode ...{public :    AVLNode() : bal(0), height(0), lch(0), rch(0), par(0) ...{    }    AVLNode(const T& oelm) : bal(0), height(
【C++】AVL树的实现及测试
AkieMo的博客
07-23 1935
AVL树也叫平衡二叉搜索树，通过旋转解决了搜索二叉树的不确定性，让整颗树趋近于一颗满二叉树。 1.左右都是一颗AVL树 2.平衡因子的绝对值不会超过1
AVL 树
qq_39749300的博客
09-14 132
一：什么是 AVL 树？ 在我的上一篇文章《二分搜索树与二分查找法》中，详细介绍了二分搜索树这种数据结构。二分搜索树最大的问题就是它并非是一棵平衡二叉树。 在给定的数据比较极端的情况下，譬如将一个递增数组中的元素依次添加到二分搜索树中，此时的二分搜素树就会退化为一个链表。 为了解决二分搜索树的这个问题，两位前苏联的计算机科学家 Georgy Adelson-Velsky 与 Evgenii Landis 发明了一种可以自平衡的二叉查找树，这种数据结构以两位科学家的名字的首字母命名，即：AVL 树。 我们再
（22）Go实现AVL树-实现和测试
哥斯拉啊啊啊哦的博客
09-04 293
继上一篇 《（21）Go实现AVL树-算法解析》 的后续 https://www.jianshu.com/p/943243f5ee1e AVL树的定义和实现 type node struct { key int value int height int left *node right *node } type avlTree struct { size int Ro...
C++ AVL树
m0_66409987的博客
06-22 59
AVL树这里直接使用键值对，即 KV模型，使用键值对是为了方便后面实现 set 和 map。AVL树节点的定义增加了一个指向父节点的指针，变成了三叉链结构，并且每个节点都增加了一个平衡因子（右子树高度 -左子树高度的值），平衡因子的初始化设置为0即可// 右树高减去左树高int _bf;
【算法与数据结构】AVL树
mjiansun的专栏
12-04 468
目录 概要 AVL树的介绍 AVL树的C实现 1. 节点 2. 旋转 AVL树的C实现(完整源码) AVL树的C测试程序 概要 本章介绍AVL树。和前面介绍"二叉查找树"的流程一样，本章先对AVL树的理论知识进行简单介绍，然后给出C语言的实现。本篇实现的二叉查找树是C语言版的，后面章节再分别给出C++和Java版本的实现。 建议：若您对"二叉查找树"不熟悉，建议先学完"二叉查找树...
avl树容器c++实现及其性能测试
piriineos的博客
06-11 1470
这个实现有个问题就是不能用于多线程，因为avl旋转的特性一次需要锁住整棵树。话不多说直接上代码：/* Created on 2018/5/19 author:HZL * 该AVL树容器不带迭代器(偷懒)，并且由于MinGW不支持SGI STL， * 故无法使用其内置的高效内存管理器alloc，而是仅仅封装了一下 * new和delete。同时由于关键的插入和删除函数使用递归方式实现 * 因...
中级C++：AVL树
FamerSaul的博客
06-25 614
AVL树的特征；平衡因子，更新平衡因子代码；左左类型：右旋；右右类型：左旋；左右类型：先左旋，再右旋；右左类型：先右旋，再左旋；验证是否是AVL树。
AVL树的实现(代码实现 + 测试) [数据结构与算法]
m0_57001006的博客
12-24 188
【代码】AVL树的实现(代码实现 + 测试) [数据结构与算法]
AVL树（含图解）
Guqing_f的博客
04-20 578
AVL树的介绍、讲解、图示、代码演示
C++中AVL树的插入实现
qq_53413129的博客
05-23 335
AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单 支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树 中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL
5、AVL树的实现
沿海奔跑的少年
11-06 891
1、我们首先要计算节点的高度和平衡因子。 // 计算每个节点的高度 int getHeight(Node&lt;K, V&gt; * node){ if (node == NULL) return 0; return node-&gt;height; } // 获得节点node的平衡因子 int getBalanceFactor(No...
AVL树详解（可视化工具）
codingriver的博客
07-27 1987
转自：AVL树(一)之 图文解析 和 C语言的实现（本文图片及文字描述基本转自该文） 代码是C#写的 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于"二叉查找树"，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。(树的高度：树中结点的最大层次) 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以.
AVL树（自平衡二叉查找树）
小熊猫的博客
04-18 491
这篇文章我是先在博客园发布的：https://www.cnblogs.com/yinhao-ing/p/10732866.html 了解AVL树之前要先了解二叉查找树（BST），BST查找元素的时间复杂度平均是O(logN)，最坏的情况是O(N)，所有的元素都接在左子树（或者右子树）就相当于一串链表了。而AVL树会对子树过高的情况进行优化，这里有个平衡因子的概念，当前节点的平衡因子=左子树高度-...
查找算法 | 平衡二叉树（AVL树）详细分析
挖坑埋你
11-01 5538
AVL:完全平衡的二叉查找树 二叉查找树可以表示动态的数据集合，对于给定的数据集合，在建立一颗二叉查找树时，二叉查找树的结构形态与关键字的插入顺序有关。如果全部或者部分地按照关键字的递增或者递减顺序插入二叉查找树的结点，则所建立的二叉查找树全部或者在局部形成退化的单分支结构。在最坏的情况下，二叉查找树可能完全偏斜，高度为n，其平均与最坏的情况下查找时间都是O(n)；而最好的情况下，二叉查找树的结...
C++中排序问题中的减治法-二叉排序树算法的实现实验分析
05-19
二叉排序树，也称为二叉搜索树，是一种数据结构，它是一棵二叉树，其中每个节点都包含一个键值，且左子树中的所有键值都小于该节点的键值，右子树中的所有键值都大于该节点的键值。通过这种方式，我们可以快速地对数据进行查找、插入和删除操作。 在排序问题中，我们可以使用减治法来实现二叉排序树算法。具体来说，我们可以将排序问题分解为两个子问题：首先，将前半部分数据排序；然后，将后半部分数据排序。在排序过程中，我们可以利用二叉排序树的特性来建立一棵树，并将数据按照顺序插入到树中。当所有数据插入完毕后，我们可以通过遍历树来将数据按照升序输出。 下面是使用C++实现二叉排序树算法的示例代码： ```cpp #include <iostream> using namespace std; // 二叉排序树结构体 struct BSTNode { int data; // 数据 BSTNode* left; // 左子树指针 BSTNode* right; // 右子树指针 }; // 创建新节点 BSTNode* createNode(int data) { BSTNode* newNode = new BSTNode; newNode->data = data; newNode->left = NULL; newNode->right = NULL; return newNode; } // 插入节点 BSTNode* insertNode(BSTNode* root, int data) { if (root == NULL) { return createNode(data); } if (data < root->data) { root->left = insertNode(root->left, data); } else { root->right = insertNode(root->right, data); } return root; } // 中序遍历输出 void inorderTraversal(BSTNode* root) { if (root != NULL) { inorderTraversal(root->left); cout << root->data << " "; inorderTraversal(root->right); } } // 测试函数 int main() { int arr[] = { 6, 3, 8, 2, 5, 7, 9 }; int n = sizeof(arr) / sizeof(arr[0]); BSTNode* root = NULL; for (int i = 0; i < n; i++) { root = insertNode(root, arr[i]); } inorderTraversal(root); return 0; } ``` 在上述代码中，我们首先定义了一个二叉排序树结构体，并实现了创建节点、插入节点、中序遍历输出等函数。接着，我们定义了一个测试函数，用于测试二叉排序树算法的正确性。在测试函数中，我们首先定义了一个数据数组，并计算出数据个数。然后，我们通过循环将每个数据插入到二叉排序树中。最后，我们调用中序遍历函数来输出排序后的数据。 通过实验对比分析，我们可以发现，使用减治法实现二叉排序树算法的时间复杂度为O(nlogn)，空间复杂度为O(n)，与其他排序算法相比，效率较高。但是，在某些情况下，由于二叉排序树的不平衡性，可能会导致算法效率下降，因此我们需要采取一些措施来保证二叉排序树的平衡性，例如AVL树、红黑树等。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

脚踏车(crush)

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值