平衡二叉搜索树(AVL)——【C++实现插入、删除等操作】

已于 2023-09-10 13:15:00 修改
阅读量551 收藏 2
点赞数 3
分类专栏： C++ 原创 数据结构 文章标签： c++ 开发语言 数据结构
于 2023-09-10 13:04:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dirty_artist/article/details/132790046
版权
原创 同时被 3 个专栏收录
175 篇文章 5 订阅
订阅专栏
C++
29 篇文章 1 订阅
订阅专栏
数据结构
14 篇文章 0 订阅
订阅专栏

在这里插入图片描述

本章完整代码gitee地址：平衡二叉搜索树

文章目录

🌳0. 前言

C++的map和set这两个容器的底层就搜索树，关于搜索树，之前此篇文章讲过：数据结构——二叉搜索树，但它可能会出现极端情况：退化为链表

image-20230906133632229

所以再次基础上，就要将这颗树变为平衡的二叉搜索树——ALV树、红黑树，本章讲解的是AVL树

🌲1. AVL树概念

AVL树俄罗斯的两位数学家G.M.Adlson-Velskii和E.M.Landis在1962年发表的论文《An algorithm for the organization of information》公开了这种结构：向二叉树插入一个新节点后，保证每个左右子树的高度之差绝对值不超过1，即可降低树的高度，减少平均搜索的长度。

将左子树减去右子树的深度的值，成为平衡因子BF（Balance Factor），由于绝对值不超过1，则平衡因子的范围是**[-1,1]**，如果超过，就说明目前这棵树不是平衡的，需要进行调整

image-20230906135941793

由于树的左右子树是平衡的，所以要对这棵树操作的时候，最多进行高度次操作：O(lonN)

满二叉树：2h-1 = N

AVL树：2h - X = N（X的范围为[1，2h-1-1]），属于O(lonN)，这个量级

🌴2. 实现AVL树

🌿2.1 结构定义

//定义成kv结构
template<class K,class V>
struct AVLTreeNode
{
	pair<K, V> _kv;
	//三叉链
	AVLTreeNode<K, V>* _left;	//左节点
	AVLTreeNode<K, V>* _right;	//右节点
	AVLTreeNode<K, V>* _parent;	//父亲节点
	int _bf;	//平衡因子

	AVLTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_bf(0)
	{}
};

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;

public:
	//功能
private：
}

🌿2.2 插入

bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        return true;
    }
    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }

    //链接
    cur = new Node(kv);
    if (parent->_kv.first > kv.first)
    {
        parent->_left = cur;
    }
    else
    {
        parent->_right = cur;
    }
    cur->_parent = parent;

    //检查
    while (parent)
    {
        //更新平衡因子
        if (cur == parent->_left)
        {
            parent->_bf--;
        }
        else
        {
            parent->_bf++;
        }

        //判断
        if (parent->_bf == 0)
        {
            //很健康，直接跳出
            break;
        }
        else if (parent->_bf == 1 || parent->_bf == -1)
        {
            //小问题，无大碍
            //继续往上更新
            //cur = parent;
            parent = parent->_parent;
            cur = 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);
            }
            else
            {
                assert(false);
            }

            break;
        }
        else
        {
            //防止写的代码有bug
            assert(false);
        }
    }
    return true;
}

我们设平衡因子为：右子树-左子树

  1. 新增左节点，parent平衡因子减一

  2. 新增右节点，parent平衡因子加一

  3. 更新后的parent平衡因子 == 0 ，说明parent所在子树高度不变，无需继续更新祖先节点

    更新后的parent平衡因子 == 1 或- 1，说明parent所在子树高度发生变化，影响祖先，需要继续更新祖先节点

  4. 更新后的parent平衡因子 == 2 或 -2，说明parent所在子树高度发生变化，且不平衡，需要对parent对所在子树进行旋转，让其平衡

这里的平衡因子起到一个检测作用，查看这棵树是否“生病”，如果发现“生病”，立即“治疗”，所以不可能出现大于2的绝对值的平衡因子

💐左单旋

单纯右边高，采用左单旋进行调整，具体情况如图：

image-20230907101404348

核心操作：

  1. `parent->right = cur->left;``
  2. ``cur->left = parent;`

左单旋实现：

//左单旋
void RotateL(Node* parent)
{
    Node* cur = parent->_right;
    Node* curleft = cur->_left;

    parent->_right = curleft;
    if (curleft)
    {
        curleft->_parent = parent;
    }
    cur->_left = parent;
    Node* ppnode = parent->_parent;
    parent->_parent = cur;

    if (parent == _root)
    {
        _root = cur;
        cur->_parent = nullptr;
    }
    else
    {
        if (ppnode->_left == parent)
        {
            ppnode->_left = cur;
        }
        else
        {
            ppnode->_right = cur;
        }
        cur->_parent = ppnode;
    }
    parent->_bf = cur->_bf = 0;
}

动态示例：

left

💐右单旋

单纯的左边高，采用右单旋进行调整，具体情况如图：

image-20230907105426442

核心操作：

  1. parent->left = cur->right;
  2. cur->right = parent;

右单旋实现：

//右单旋
void RotateR(Node* parent)
{
    Node* cur = parent->_left;
    Node* curRight = cur->_right;

    parent->_left = cur->_right;
    //防止curRight为空
    if (curRight)
    {
        curRight->_parent = parent;
    }

    cur->_right = parent;
    //保存父亲的父亲节点
    Node* ppnode = parent->_parent;
    parent->_parent = cur;

    if (parent == _root)	
    {
        _root = cur;
        cur->_parent = nullptr;
    }
    else
    {
        if (ppnode->_left == parent)
        {
            ppnode->_left = cur;
        }
        else
        {
            ppnode->_right = cur;
        }
        cur->parent = ppnode;
    }
    //更新平衡因子
    parent->_bf = cur->_bf = 0;
}

动图示例：

right

💐左右双旋

新插入节点在较高左子树的右侧，采用右左双旋，具体情况如图：

image-20230907191809620

平衡因子更新需要看cur->right的平衡因子情况：

image-20230907193212207

  1. curRight == 0，它就是插入节点，全部更新为0
  2. curRight == 1，c插入，cur->_bf = -1，parent->_bf = 0
  3. curRight == -1，b插入，cur->_bf = 0，·parent->_bf = 1`

核心操作：

  1. 以parent->left为旋转点左旋
  2. 以parent为旋转点右旋
  3. 根据curRight->_bf调整平衡因子

💐右左双旋

新插入节点在较高右子树的左侧，采用右左双旋，具体情况如图：

image-20230907171534105

这里平衡因子的更新，不能和单旋一样直接更新为0，要分情况，我们这里主要是看cur->left的平衡因子

image-20230907190633396

  1. curLeft->_bf == 0，则它就是插入节点，平衡因子全部更新为0
  2. curLeft->_bf == 1，c插入，cur->_bf = 0，parent->_bf = -1
  3. curLeft->_bf == -1,b插入，cur->_bf = 1，parent->_bf = 0

核心操作：

  1. 以为parent->right为旋转点右旋
  2. 以parent为旋转点左旋
  3. 根据curLeft->_bf更新平衡因子

右左双旋代码实现：

	//右左双旋
	void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curLeft = cur->_left;
		int bf = curLeft->_bf;
        
		RotateR(parent->_right);
		RotateL(parent);

		if (bf == 0)
		{
			//curLeft为新增节点
			cur->_bf = 0;
			curLeft->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == 1)
		{
			//curLeft右子树插入
			cur->_bf = 0;
			curLeft->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == -1)
		{
			//curLeft左子树插入
			cur->_bf = 1;
			curLeft->_bf = 0;
			parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

动图示例：

r_lRtate

🌿2.3 查找

//查找
Node* Find(const K& key)
{
    return _Find(_root, key);
}

因为_root是私有成员，外部无法使用，所以我们设置一个子函数

Node* _Find(Node* root, const K& key)
{
    if (root == nullptr || root->_kv.first == key)
        return root;

    if (root->_kv.first > key)
        return _Find(root->_left, key);
    else
        return _Find(root->_right, key);
}

🌿2.4 删除

删除操作就不多说了，注释写的特别清楚

基本思路就是：

  1. 删除元素
  2. 更新平衡因子

与插入类似，但细节还是很多

//删除
bool Erase(const K& key)
{
    return _Erase(key);
}

子函数：

bool _Erase(const K& key)
{
    Node* parent = nullptr;
    Node* cur = _root;
    //查找元素
    while (cur)
    {
        if (cur->_kv.first > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else if (cur->_kv.first < key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else
            break;
    }
    //该元素不存在
    if (cur == nullptr)
        return false;
    //删除元素

    //1.左右子树都为空
    if (cur->_left == nullptr && cur->_right == nullptr)
    {
        //根节点直接删除退出
        if (cur == _root)
        {
            delete _root;
            _root = nullptr;
            return true;
        }
        if (cur == parent->_left)
        {
            //删除的是左孩子
            parent->_bf++;
            parent->_left = nullptr;
        }
        else
        {
            //删除的是右孩子
            parent->_bf--;
            parent->_right = nullptr;
        }
        delete cur;
        cur = parent;
    }
    else if (cur->_left == nullptr)	//左子树为空
    {
        if (cur == _root)
        {
            _root = cur->_right;
            cur->_right->_parent = nullptr;
            delete cur;
            cur = nullptr;

            return true;
        }
        //因为是平衡二叉树，如果左子树为空，那么右子树至多只有一个节点
        //这里前面已经判断了双空的情况，那么肯定右子树只有一个节点,直接删除即可
        Node* curRight = cur->_right;

        //替换元素
        cur->_kv.first = curRight->_kv.first;
        cur->_kv.second = curRight->_kv.second;

        //删除节点
        cur->_right = nullptr;
        delete curRight;
        curRight = nullptr;
        //删右孩子，父节点平衡因子-1
        cur->_bf--;
    }
    else if (cur->_right == nullptr)	//右子树为空
    {
        if (cur == _root)
        {
            _root = cur->_left;
            cur->_left->_parent = nullptr;
            delete cur;
            cur = nullptr;
            return true;
        }
        //与左子树为空同理
        Node* curLeft = cur->_left;

        //替换元素
        cur->_kv.first = curLeft->_kv.first;
        cur->_kv.second = curLeft->_kv.second;

        //删除节点
        cur->_left = nullptr;
        delete curLeft;
        curLeft = nullptr;
        //删除左孩子，父节点平衡因子+1
        cur->_bf++;
    }
    else
    {
        //左右子树都不为空
        //以左子树最大元素为例
        parent = cur;	//前驱
        Node* prev = cur->_left;	//找左子树最大元素
        while (prev->_right)
        {
            parent = prev;
            prev = prev->_right;
        }
        //替换元素
        cur->_kv.first = prev->_kv.first;
        cur->_kv.second = prev->_kv.second;

        //右边肯定没有元素了，因为找的就是最大的元素：左子树里面的最右边
        if (parent->_left == prev)
        {
            parent->_left = prev->_left;	
            parent->_bf++;
        }
        else
        {
            parent->_right = prev->_left;
            parent->_bf--;
        }
        delete prev;
        prev = nullptr;
        //指向删除节点父亲
        cur = parent;
    }

    parent = cur->_parent;

    //重新找调整位置
    if (cur->_bf == -2 || cur->_bf == 2)
    {
        if (cur->_bf == -2)
        {
            Node* curLeft = cur->_left;
            parent = cur;
            cur = curLeft;
        }
        else
        {
            Node* curRight = cur->_right;
            parent = cur;
            cur = curRight;
        }
    }

    //if (cur->_bf == 0 && parent != nullptr && abs(parent->_bf) == 2)
    //{
    //	if (cur = parent->_left)
    //		cur = parent->_right;
    //	else
    //		cur = parent->_left;
    //}

    while (parent)
    {
        //更新父亲的平衡因子
        parent->_bf = UpdateBf(parent);

        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 if (parent->_bf == 2)
            {
                //cur->_bf == 0时
                RotateL(parent);
                //再更新一次
                parent->_bf = UpdateBf(parent);
            }
            else if (parent->_bf == -2)
            {
                RotateR(parent);
                parent->_bf = UpdateBf(parent);
            }
            else
            {
                assert(false);
            }
        }

        cur = parent;
        parent = cur->_parent;
    }
    return true;
}
int UpdateBf(Node* root)
{
    if (!root)
        return 0;
    int leftH = _Height(root->_left);
    int rightH = _Height(root->_right);
    return rightH - leftH;
}

🌿2.5 树的高度

int _Height(Node* root)
{
    if (root == nullptr)
        return 0;

    //记录深度
    int leftH = _Height(root->_left);
    int rightH = _Height(root->_right);

    //记录更深的那一个
    return std::max(leftH, rightH) + 1;
}

🌿2.6 是否为平衡树

bool _IsAVLTree(Node* root)
{
    //空树符合AVL树
    if (root == nullptr)
        return true;

    //左子树的高度
    int leftH = _Height(root->_left);
    //右子树高度
    int rightH = _Height(root->_right);

    //看平衡因子是否符合
    int bf = rightH - leftH;

    if (bf != root->_bf)
        return false;

    //平衡因子绝对值不大于
    //在一次递归左右子树
    return abs(bf) < 2 && _IsAVLTree(root->_left) && _IsAVLTree(root->_right);	
}

🌿2.7 遍历（中序）

void _InOrder(Node* root)
{
    if (root == nullptr)
        return;

    _InOrder(root->_left);
    cout << root->_kv.first << " ";
    _InOrder(root->_right);
}

那本次分享就到这里咯，AVL树主要是重点了解其中是如何变平衡的（各种旋转），在实际中，我们只有使用C++里面的map和set（底层是红黑树）。

我们下期再见咯，如果还有下期的话。

Tips：
如果代码有bug，希望大家能指出来，看了网上好多的都有bug
不知道这个有没有bug，我测了一些数据，目前没发现bug

加法器+
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
14.3 二叉搜索树的操作和实现 14.3.1 类binarySearchTree 14.3.2 搜索 14.3.3 插入 14.3.4 删除 14.3.5 二叉搜索树的高度 14.4 带有相同关键字元素的二叉搜索树 14.5 索引二叉搜索树 14.6 应用 14.6.1 直方图 14.6.2...
AVL树C++实现——高度平衡二叉搜索树
Brant_zero的博客
11-15 698
C++实现，详解AVL树，AVL树的插入(循环实现)以及测试用例。
高度平衡二叉搜索树（AVL树）
bang___bang_的博客
07-20 275
本文详解AVL树的插入操作，分为2种情况：不旋转和旋转；旋转又细分4个情况:左单璇、右单旋、左右双旋、右左双旋。文章图文并茂，详细讲解实现操作和代码实现。不要从轮子重新造起，要站在巨人的肩膀上！深究原理和实现细节是绝对有帮助的！
数据结构与算法——二叉搜索树BST与自平衡二叉搜索树AVL（C++）
Ripplesding的博客
07-27 407
1 二叉搜索树(BST) 1.1 二叉搜索树的优点 树的结构使得二分查找算法如鱼得水，使用树进行查找、删除和插入等操作综合了列表与向量的优点，在动态与静态之间达到了一个平衡。 其中，树搜索的时间复杂度与树高直接相关，树越高，时间复杂度越大。本文讲述二叉搜索树的基本原型以及保证树平衡的自平衡二叉搜索树的原理。 首先，介绍二叉搜索树的基本原型。二叉搜索树继承了二叉树类，扩写了查找，插入与删除等操作。 #pragma once #include "../dsa_bintree_20200720/bintree.h
平衡二叉搜索树：AVL树的实现与分析 以及 统一重平衡算法 （C++）
amoscykl的博客
08-11 1410
平衡二叉搜索树 既然二叉搜索树的性能主要取决于高度,故在节点数目固定的前提下,应尽可能地降低高度。 相应地,应尽可能地使兄弟子树的高度彼此接近,即全树尽可能地平衡。   等价变换 等价二叉搜索树：若两棵二叉搜索树的中序遍历序列相同,则称它们彼此等价;反之亦然。   旋转调整 最基本的修复手段，通过围绕特定节点的旋转，实现等价前提下的局部拓扑调整。 zig和zag：    ...
C++ —— 二叉搜索树
原来45的博客
09-17 1081
二叉搜索树概念 二叉搜索树操作 1. 二叉搜索树的查找 2.二叉搜索树的插入 3. 二叉搜索树的删除 二叉搜索树的应用 1. K模型 2. KV模型 二叉搜索树的性能分析 二叉搜索树的实现（K&&KV）和测试（KV）
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 5822
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
C/C++数据结构（十一）—— 平衡二叉树（AVL树）
热门推荐
Edison's 小宇宙
01-19 2万+
平衡二叉树又称为 AVL 树，其实就是一颗 平衡的二叉搜索树，解决了二叉搜索树的不平衡问题。
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2114
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1211
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
数据结构C++描述
03-15
11.1.8 二叉搜索树的高度 327 11.2 AVL树 328 11.2.1 基本概念 328 11.2.2 AVL树的高度 328 11.2.3 AVL树的描述 329 11.2.4 AVL搜索树的搜索 329 11.2.5 AVL搜索树的插入 329 11.2.6 AVL搜索树的删除 332 11.3 红－...
数据结构算法与应用-C++语言描述
10-20
11.1.8 二叉搜索树的高度 327 11.2 AVL树 328 11.2.1 基本概念 328 11.2.2 AVL树的高度 328 11.2.3 AVL树的描述 329 11.2.4 AVL搜索树的搜索 329 11.2.5 AVL搜索树的插入 329 11.2.6 AVL搜索树的删除 332 11.3 红－...
C++语言描述(PDF合集)
07-13
11.1.8 二叉搜索树的高度 327 11.2 AVL树 328 11.2.1 基本概念 328 11.2.2 AVL树的高度 328 11.2.3 AVL树的描述 329 11.2.4 AVL搜索树的搜索 329 11.2.5 AVL搜索树的插入 329 11.2.6 AVL搜索树的删除 332 11.3 红－...
数据结构 C++描述
08-04
11.1.8 二叉搜索树的高度 327 11.2 AVL树 328 11.2.1 基本概念 328 11.2.2 AVL树的高度 328 11.2.3 AVL树的描述 329 11.2.4 AVL搜索树的搜索 329 11.2.5 AVL搜索树的插入 329 11.2.6 AVL搜索树的删除 332 11.3 红－...
C语言——函数指针与指针函数
qq_67319052的博客
05-19 615
函数指针与指针函数有什么区别？
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 688
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
Python教程：使用Python和PyQt编写进制转换器工具
最新发布
复现的博客
05-23 265
在现代计算中，进制转换是一项常见且重要的任务。为了简化这个过程，我们也可以利用Python和PyQt自己写一个直观且易于使用的进制转换器工具。这个工具将支持二进制、八进制、十进制和十六进制的相互转换，并提供良好的用户界面和交互体验。
c++ const 的多种用途
05-17 153
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左...AVL树则是一种自平衡的二叉搜索树，它保证任何节点的左右子树高度差不超过1，因此能够保证树的查找、插入、删除等操作的时间复杂度为O(logN)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

加法器+

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

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

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

打赏作者

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

抵扣说明：

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

余额充值