AVL树（平衡二叉树）

最新推荐文章于 2022-02-14 10:01:48 发布
最新推荐文章于 2022-02-14 10:01:48 发布
阅读量385 收藏
点赞数 2
分类专栏： 数据结构 c++ 文章标签： 二叉树 搜索 平衡树-平衡化旋转
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simplehap/article/details/69453819
版权

AVL树的概念

一棵AVL树，要么是空树，要么是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。

平衡因子

每个节点都有一个平衡因子，任一节点的平衡因子是-1,0,1。每个节点的平衡因子等于右子树的高度减去左子树的高度。

AVL树的效率

如果一棵搜索二叉树的高度是平衡的，它就是AVL树。如果它有N个节点，它的高度保持在O((log2)N)（log以2为底N的对数），插入，删除，查找的时间复杂度O((log2)N)（log以2为底N的对数）。

平衡化旋转

如果在一棵原来是AVL树中插入一个新节点，造成了不平衡。此时需要进行调整，使之重新平衡化。平衡化旋转分为两类：单旋（左单旋和右单旋）、双旋（左右双旋和右左双旋）。

## 左单旋 ##

这里写图片描述
代码：

    void RotateL(Node* parent)//左旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        Node* ppNode = parent->_parent;

        subR->_left = parent;
        parent->_parent = subR;

        if (ppNode == NULL)//parent为根节点
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else//ppNode != NULL
        {
            if (parent == ppNode->_left)
                ppNode->_left = subR;
            else
                ppNode->_right = subR;
            subR->_parent = ppNode;
        }
        parent->_bf = subR->_bf = 0;
    }

## 右单旋 ##
这里写图片描述
代码：

void RotateR(Node* parent)//右旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;

        if (subLR)
            subLR->_parent = parent;

        Node* ppNode = parent->_parent;

        subL->_right = parent;
        parent->_parent = subL;

        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (parent == ppNode->_left)
                subL = ppNode->_left;
            else
                subL = ppNode->_right;
            subL->_parent = ppNode;
        }
        parent->_bf = subL->_bf = 0;
    }

## 左右双旋 ##
有三种情况，由subLR决定：
第一种：（a/b/c/d都不存在，60为新插节点）
这里写图片描述
第二种：
这里写图片描述
第三种：
这里写图片描述
代码：

void RotateLR(Node* parent)//左右双旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        int bf = subLR->_bf;

        RotateL(subL);
        RotateR(parent);
        //调整平衡因子
        if (bf == 0)
        {
            parent->_bf = subL->_bf = subLR->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = 0;
            subL->_bf = -1;
            subLR->_bf = 0;
        }
        else//bf == -1
        {
            parent->_bf = 1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
    }

## 右左双旋##

有三种情况，由subLR决定：
第一种：（a/b/c/d都不存在，60为新插节点）
这里写图片描述
第二种：
这里写图片描述
第三种：
这里写图片描述
代码：

void RotateRL(Node* parent)//右左双旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        int bf = subRL->_bf;

        RotateR(subR);
        RotateL(parent);
        //调整平衡因子
        if (bf == 0)
        {
            parent->_bf = subR->_bf = subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else//bf == -1
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
    }

AVL树的插入

和搜索二叉树的类似，唯一不同的是要调整平衡因子。
parent->_bf == 2 && cur->_bf == 1进行左旋
parent->_bf == -2 && cur->_bf == -1进行右旋
parent->_bf == 2 && cur->_bf == -1进行右左双旋
parent->_bf == -2 && cur->_bf == 1进行左右双旋

代码：

bool Insert(const K& key, const V& value)//插入
    {
        if (_root == NULL)//空树，直接插入
        {
            _root = new Node(key, value);
            return true;
        }

        Node* cur = _root;
        Node* parent = NULL;
        //找插入节点的位置
        while (cur)
        {
            if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else//已经有该节点，直接返回
            {
                return false;
            }
        }
        //插入节点
        cur = new Node(key, value);

        if (key < parent->_key)
        {   
            parent->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        //调节平衡因子
        while (parent)
        {
            //新插入的节点的父节点改变平衡因子
            if (cur == parent->_left)
                parent->_bf--;
            else
                parent->_bf++;

            //根据平衡因子的大小，进行调整树
            if (parent->_bf == 0)//平衡因子为0，直接返回
                return true;
            else if (abs(parent->_bf) == 1)//平衡因子为正负1，向上继续找
            {
                cur = parent;
                parent = cur->_parent;
            }
            else//平衡因子为正负2，进行旋转
            {
                if (parent->_bf == 2)
                {
                    if (cur->_bf == 1)
                    {
                        RotateL(parent);
                        return true;
                    }
                    else//cur->_bf == -1
                    {
                        RotateRL(parent);
                        return true;
                    }
                }
                else//parent->_bf == -2
                {
                    if (cur->_bf == -1)
                    {
                        RotateR(parent);
                        return true;
                    }
                    else//cur->_bf == 1
                    {
                        RotateLR(parent);
                        return true;
                    }
                }
            }
        }
        return true;
    }

AVL树的查找

和搜索二叉树查找一样

代码：

bool Find(const K& key)//查找
    {
        if (_root == NULL)
            return false;

        Node* cur = _root;

        while (cur)
        {
            if (key < cur->_key)
            {
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else
            {
                return true;
            }
        }
        return false;
    }

AVL树的删除

和搜索二叉树的类似，唯一不同的是要调整平衡因子

判断一棵树是不是平衡树

两个条件：1、是搜索二叉树2、左右子树的高度差的绝对值不超过1

代码：

bool IsBalance()//判断是否为平衡树
    {
        if (_root == NULL)
            return true;
        Node* cur = _root;
        //判断左子树和右子树高度差的绝对值是否小于2
        int leftDepth = _Depth(cur->_left);
        int rightDepth = _Depth(cur->_right);
        if (abs(rightDepth - leftDepth) < 2)
            return true;
        else
            return false;
    }

    int _Depth(Node* cur)//递归求树的高度
    {
        if (cur == NULL)
            return 0;
        int left = _Depth(cur->_left);
        int right = _Depth(cur->_right);

        return left > right ? left + 1 : right + 1;
    }

整体代码实现：

"AVLTree.h"
#pragma once

template <class K,class V>
struct AVLTreeNode
{
    K _key;
    V _value;

    int _bf;//平衡因子

    AVLTreeNode<K, V>* _left;
    AVLTreeNode<K, V>* _right;
    AVLTreeNode<K, V>* _parent;

    AVLTreeNode(const K& key,const V& value)//构造函数
        :_key(key)
        , _value(value)
        , _bf(0)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
    {}
};

template <class K,class V>
class AVLTree
{
    typedef AVLTreeNode<K, V> Node;
public:
    AVLTree()//构造函数
        :_root(NULL)
    {}

    ~AVLTree()//析构函数
    {
         _Destory(_root); 
    }

    bool Insert(const K& key, const V& value)//插入
    {
        if (_root == NULL)//空树，直接插入
        {
            _root = new Node(key, value);
            return true;
        }

        Node* cur = _root;
        Node* parent = NULL;
        //找插入节点的位置
        while (cur)
        {
            if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else//已经有该节点，直接返回
            {
                return false;
            }
        }
        //插入节点
        cur = new Node(key, value);

        if (key < parent->_key)
        {   
            parent->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        //调节平衡因子
        while (parent)
        {
            //新插入的节点的父节点改变平衡因子
            if (cur == parent->_left)
                parent->_bf--;
            else
                parent->_bf++;

            //根据平衡因子的大小，进行调整树
            if (parent->_bf == 0)//平衡因子为0，直接返回
                return true;
            else if (abs(parent->_bf) == 1)//平衡因子为正负1，向上继续找
            {
                cur = parent;
                parent = cur->_parent;
            }
            else//平衡因子为正负2，进行旋转
            {
                if (parent->_bf == 2)
                {
                    if (cur->_bf == 1)
                    {
                        RotateL(parent);
                        return true;
                    }
                    else//cur->_bf == -1
                    {
                        RotateRL(parent);
                        return true;
                    }
                }
                else//parent->_bf == -2
                {
                    if (cur->_bf == -1)
                    {
                        RotateR(parent);
                        return true;
                    }
                    else//cur->_bf == 1
                    {
                        RotateLR(parent);
                        return true;
                    }
                }
            }
        }
        return true;
    }

    bool Find(const K& key)//查找
    {
        if (_root == NULL)
            return false;

        Node* cur = _root;

        while (cur)
        {
            if (key < cur->_key)
            {
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                cur = cur->_right;
            }
            else
            {
                return true;
            }
        }
        return false;
    }

    void RotateL(Node* parent)//左旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        Node* ppNode = parent->_parent;

        subR->_left = parent;
        parent->_parent = subR;

        if (ppNode == NULL)//parent为根节点
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else//ppNode != NULL
        {
            if (parent == ppNode->_left)
                ppNode->_left = subR;
            else
                ppNode->_right = subR;
            subR->_parent = ppNode;
        }
        parent->_bf = subR->_bf = 0;
    }

    void RotateR(Node* parent)//右旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;

        if (subLR)
            subLR->_parent = parent;

        Node* ppNode = parent->_parent;

        subL->_right = parent;
        parent->_parent = subL;

        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (parent == ppNode->_left)
                subL = ppNode->_left;
            else
                subL = ppNode->_right;
            subL->_parent = ppNode;
        }
        parent->_bf = subL->_bf = 0;
    }

    void RotateLR(Node* parent)//左右双旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        int bf = subLR->_bf;

        RotateL(subL);
        RotateR(parent);
        //调整平衡因子
        if (bf == 0)
        {
            parent->_bf = subL->_bf = subLR->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = 0;
            subL->_bf = -1;
            subLR->_bf = 0;
        }
        else//bf == -1
        {
            parent->_bf = 1;
            subL->_bf = 0;
            subLR->_bf = 0;
        }
    }

    void RotateRL(Node* parent)//右左双旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        int bf = subRL->_bf;

        RotateR(subR);
        RotateL(parent);
        //调整平衡因子
        if (bf == 0)
        {
            parent->_bf = subR->_bf = subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            parent->_bf = -1;
            subR->_bf = 0;
            subRL->_bf = 0;
        }
        else//bf == -1
        {
            parent->_bf = 0;
            subR->_bf = 1;
            subRL->_bf = 0;
        }
    }

    void InOrder()//中序打印
    {
        _InOrder(_root);
        cout << endl;
    }

    bool IsBalance()//判断是否为平衡树
    {
        if (_root == NULL)
            return true;
        Node* cur = _root;
        //判断左子树和右子树高度差的绝对值是否小于2
        int leftDepth = _Depth(cur->_left);
        int rightDepth = _Depth(cur->_right);
        if (abs(rightDepth - leftDepth) < 2)
            return true;
        else
            return false;
    }

protected:
    void _Destory(Node* root)  //销毁
    {  
        if (root == NULL)  
            return;  
        _Destory(root->_left);  
        _Destory(root->_right);  
        delete root;  
    }  
    int _Depth(Node* cur)//递归求树的高度
    {
        if (cur == NULL)
            return 0;
        int left = _Depth(cur->_left);
        int right = _Depth(cur->_right);

        return left > right ? left + 1 : right + 1;
    }

    void _InOrder(Node* cur)
    {
        if (cur == NULL)
            return;
        _InOrder(cur->_left);
        cout << cur->_key << " ";
        _InOrder(cur->_right);
        }

protected:
    Node* _root;
};

void TestAVLTree()
{
    //int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
    AVLTree<int, int> t;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        t.Insert(a[i],i);
    }
    t.InOrder();
    cout << "IsBalance?" << t.IsBalance() << endl;


    t.Find(4);
    t.Find(2);
    t.Find(6);
    t.Find(8);
    t.Find(16);
    t.Find(18);
    t.Find(0);
    t.Find(100);
}
"Test.c"
#include <iostream>
#include <stdlib.h>

using namespace std;

#include "AVLTree.h"

int main()
{
    TestAVLTree();
    return 0;
}
simplehap
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
avl平衡树
wejboke626的博客
12-24 264
一、本博客主要内容： 1、平衡树的概念，性质 2、平衡树实现 1、平衡树节点介绍 2、构造/拷贝构造/运算符重载/树拷贝 3、插入节点 4、删除节点 5、旋转 ...
C++:图解AVL平衡二叉树的原理
qq_42613519的博客
02-27 208
1. AVL树的性质 AVL树是一种平衡二叉树，一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL树 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1) 2. AVL树的操作 ...
第12章 AVL平衡树是怎么平衡的？
入凡尘狼性不足
06-22 366
第十二章 AVL平衡树 12-1 平衡树和AVL 12-2 计算节点高度和平衡因子 12-3 检查二分搜索树性质和平衡性 12-4 旋转操作的基本原理 12-5 左旋转和右旋转的实现 12-6 LR和RL 12-7 从AVL树中删除元素 12-8 基于AVL树的集合和映射 12-1 平衡树和AVL AVL是两个发明人名字的缩写：G. M. Adelson-Velsky and E. M. Landis 1962年论文首次提出，是最早的自平衡二分搜索树结构。 什么是平衡二叉树？ 12-2 计算节点高度和
【学习笔记】平衡二叉树（AVL树）简介及其查找、插入、建立操作的实现
Cassie_zkq的博客
10-13 1233
  目录 平衡二叉树简介： 各种操作实现代码：   详细内容请参见《算法笔记》P319 初始AVL树，一知半解，目前不是很懂要如何应用，特记录下重要内容，以供今后review。   平衡二叉树简介： 平衡二叉树由两位前苏联科学家提出，并以两者的名字命名，故称AVL树。 AVL树是一棵二叉搜索树（BST），平衡指的是对AVL树的任意结点，其左子树和右子树高度之差的绝对值不超过1。...
AVLtree_c_avl_平衡二叉树_avltree_
10-02
综上所述，"AVLtree_c_avl_平衡二叉树_avltree_"这个项目可能是用C语言实现了一个AVL树的数据结构，并提供了对树的增删改查操作，同时具备用户友好的交互界面。这个项目对于理解和实践AVL树的概念、操作和性能优化...
AVL，平衡二叉树模板
04-19
二叉树模板
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有以下性质： * 每个节点的左...
AVLTree 平衡二叉树c++实现
06-26
AVL树是一种自平衡的二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis在1962年提出，因此得名AVL树。这种数据结构在查找、插入和删除操作上的平均时间复杂度都是O(log n)，这得益于其严格的平衡性质。AVL树的主要...
数据库技术计算机考试题,计算机等级考试三级数据库技术笔试真题及答案.doc...
weixin_29543187的博客
07-08 318
计算机等级考试三级数据库技术笔试真题及答案2010年3月计算机等级考试三级数据库技术笔试真题一、选择题(每小题1分，共60分)下列各题A)、B)、C)、D)四个选项中，只有一个选项是正确的。请将正确选项涂写在答题卡相应位置上，答在试卷上不得分。(1)服务程序是一类辅助性程序，它提供各种软件运行时所需的服务。下列哪一个属于服务程序?A)语言处理程序B)调试程序C)操作系统D)数据库管理系统(2)八进...
关于AVL树的总结
ALTLI的博客
12-29 2770
关于AVL树的总结 定义 AVL树 一棵空的二叉树是AVL树 一棵非空的二叉树是AVL树，必须满足： （1）左右子树也是AVL树 （2）左右子树高度之差的绝对值小于等于1 AVL搜索树 既是AVL树也是二叉搜索树 索引AVL搜索树 既是AVL树也是索引二叉搜索树 性质 任意n个元素都能构成一棵高度为O(logn)的AVL树 AVL搜索树的搜索、插入、删除的时间复杂性都为O(logn) 平衡因子：左...
AVL树详解（可视化工具）
codingriver的博客
07-27 1952
转自：AVL树(一)之 图文解析 和 C语言的实现（本文图片及文字描述基本转自该文） 代码是C#写的 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于"二叉查找树"，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。(树的高度：树中结点的最大层次) 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以.
数据结构选择题
qq_40907977的博客
09-21 9839
1、数据元素及其关系在计算机存储器内的表示，称为数据的 ( ） A.逻辑结构 B.存储结构 C.线性结构 D.非线性结构 2、某带头结点的单链表的头指针为 head，判定该链表为非空的条件 是( ） A.headNULL B.head->nextNULL C.head!=NULL D.head->next!=NULL 3、导致栈上溢的操作是 ( > A.栈满时执行的出栈 B.栈满时执行的入栈 C.栈空时执行的出栈 D.栈空时执行的入栈 4、 设数组 A[m]为循环队列 Q 的存储空间，
关于红黑树和AVL树，以下哪种说法不正确？----腾讯2016研发工程师在线模拟笔试题
chengonghao的博客
07-10 7352
关于红黑树和AVL树，以下哪种说法不正确？ 正确答案: D   你的答案: 空 (错误) 两者都属于自平衡二叉树 两者查找,插入，删除的时间复杂度相同 包含n个内部节点的红黑树的高度是O(log(n)) JDK的TreeMap是一个AVL的实现 添加笔记 求解答(14) 收藏 纠错 关于红黑树和AV
判断一棵树是不是AVL树
一息尚存 从吾所好
04-20 1455
这里的AVL树指的是，在BST树的基础上，满足任意结点的平衡因子绝对值小于2 判断主程序： bool JudgeAvl(TreeNode *root, int min, int max, int &deepth){ if(root == NULL) return true; if(root->val val > max) return false; //主要判断符不
计算机三级数据库选择题题库百度云,2016计算机等级考试三级数据库选择真题...
weixin_42277672的博客
06-25 314
一、选择题(每小题1分，共60分)下列各题A)、B)、C)、D)四个选项中，只有一个选项是正确的。请将正确选项涂写在答题卡相应位置上，答在试卷上不得分。(1)服务程序是一类辅助性程序，它提供各种软件运行时所需的服务。下列哪一个属于服务程序?A)语言处理程序B)调试程序C)操作系统D)数据库管理系统(2)八进制数67.54转换成二进制数是多少?A)110111.101101B)110111.1011...
重邮2020年硕士研究生入学考试（《数据结构》802）自己做的部分答案
weixin_45626900的博客
12-09 4956
2020年 硕士研究生入学考试（《数据结构》802） *同为考研人，分享学习内容，愿大家考研路上不孤独！一定上岸！ 欢迎指正与讨论！ 一、选择题(本大题共15小题,每小题2分,共30分) 1.设三个函数f，g，h，分别为fn)=1000n3+n^2+1000，g(n)= 1000n^3+5000n2，h(n)=n3/2+5000nlgn,下列哪个关系不立: A. fn)=O(g(n)) B. gn)=O(f(n)) C.h(n)=O(n^3/2) D.h(n)=O(nlgn) 我的答案：D 解析：暂无 2.
图解：什么是AVL树？（删除总结篇）
Z景明的博客
05-21 1267
上一篇文章讨论了平衡二叉树的插入操作，没有看的可以去看一下 图解：什么是AVL树？，有助于理解今天要讲的平衡二叉树的删除操作。平衡二叉树的删除操作与插入操作类似，先执行标准的BST删除操...
AVL树详解
热门推荐
Allence的博客
02-14 1万+
一、简介 AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。 上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。 如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状..
avl平衡二叉树源码
最新发布
06-26
然而，我可以为你概述AVL平衡二叉树的基本结构和关键算法： 1. **节点结构**：每个节点包含键值、左子节点、右子节点以及平衡因子。在许多编程语言中，可能有如下的定义： ```c++ struct AVLNode { int key; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值