平衡搜索树—AVLTree

最新推荐文章于 2022-06-20 17:20:46 发布
最新推荐文章于 2022-06-20 17:20:46 发布
阅读量198 收藏
点赞数
分类专栏： C++ 文章标签： AVL树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adorable_/article/details/81073621
版权

  AVL树又称作高度平衡二叉树，它实际上是一种优化了的搜索二叉树。我们知道，由于二叉搜索树存在缺陷，有可能会退化成单链表，这样的话搜索的效率就降低了。为了将二叉搜索树的效率控制在O(logN)的级别，所以我们要给二叉搜索树加上一些条件，使得二叉搜索树高度平衡，时间复杂度为O(logN)。

性质：

  1. 左子树和右子树的高度之差的绝对值不超过1
  2. 树中的每个左子树和右子树都是AVL树
  3. 每个节点都有一个平衡因子(balancefactor–bf),任一节点的平衡因子是-1,0,1。(每个节点的平衡因子等于右子树的高度减去左子树的高度)

AVL树

平衡旋转：
  如果一棵树原来是平衡的二叉搜索树，现在向里面插入一个结点，造成了不平衡，这时候我们就要调整这棵树的结构，使之重新平衡。首先我们来看看造成不平衡的结构都有哪几种以及如何调整。

（1）由插入引起的平衡旋转
平衡因子的更新原则：

1、右边增加，父亲bf++
2、 左边增加，父亲bf- -

  • 父亲bf == 0，结束更新，返回（子树高度不变）
  • 父亲b f== -1或1，子树高度变了，继续往上更新
  • 父亲bf == 2或-2，子树不再是AVL树，需要旋转，变平衡

注意：所有的插入都是建立在平衡二叉树的基础之上的。

左单旋
右单旋
左右双旋

关于左右双旋，平衡因子有以下几种情况：
平衡因子

总结：
  如果是左右双旋的话，经过旋转之后，各个节点的平衡因子有三种情况。这三种情况与subLR的平衡因子有关。而subLR的平衡因子有三种情况：0、1、-1。如果为0则表示subLR或者是subLR的子树，此时高度不变。如果是1则表示在subLR的右子树插入。如果是-1则表示在subLR的左子树插入。

右左双旋和左右双旋为对称结构，可参照左右双旋得出。
平衡因子

（2）由删除引起的平衡旋转
  首先必须明确删除只会影响从删除点到根节点路径上的结点，不会影响删除点之后的结点。当然删除与二叉搜索树的删除一样，将删除结点有两个孩子的这种情况转换成只有一个孩子或者没有孩子的情况，然后再进行删除。当然删除之后树还要保持平衡。如果只有一个根节点的话直接删除就行。
描述
描述
描述
描述
描述

基本实现：

#pragma once

#include <iostream>
#include <assert.h>

using namespace std;

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(K key, 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(const AVLTree<K, V>& tree)
        :_root(NULL)
    {
        _Copy(_root, tree._root);
    }
    AVLTree<K, V>& operator=(const AVLTree<K, V>& tree)
    {
        if (this != &tree)
        {
            AVLTree<K, V> tmp(tree);
            swap(_root, tmp._root)
        }
        return *this;
    }
    ~AVLTree()
    {
        _Destroy(_root);
    }

    bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);    //空树时直接插入
            return true;
        }
        Node* parent = NULL;
        Node* cur = _root;
        while (cur)                 //寻找插入的位置
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;       //如果已经存在该元素，则插入失败
            }
        }
        cur = new Node(key, value);
        if (parent->_key < key)
        {
            parent->_right = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_left = cur;
            cur->_parent = parent;
        }

        //调节平衡因子
        //1.更新平衡因子
        while (parent)
        {
            if (cur == parent->_right)     //插入节点为parent的右节点，parent平衡因子++
            {
                parent->_bf++;
            }
            else                         //插入节点为parent的左节点，parent平衡因子--
            {
                parent->_bf--;
            }

            if (parent->_bf == 0)         //父亲bf==0，表示树的高度不变，此时就是AVL树
            {
                break;
            }
            else if (parent->_bf == -1 || parent->_bf == 1)        //子树高度变了，继续往上更新
            {
                cur = parent;
                parent = parent->_parent;
            }
            else                        //父亲bf==2或-2，不再满足AVL树，需要旋转恢复平衡
            {
                //旋转
                if (parent->_bf == 2)      //parent的右子树高
                {
                    if (cur->_bf == 1)     //parent的子树也是右子树高，进行左单旋
                    {
                        RotateL(parent);
                    }
                    else                  //parent的子树的左子树高，进行右左双旋
                    {
                        RotateRL(parent);  
                    }
                }
                else                      //parent的左子树高
                {
                    if (cur->_bf == -1)    //parent的子树也是左子树高，进行右单旋
                    {
                        RotateR(parent);
                    }
                    else                  //parent的子树的右子树高，进行左右双旋
                    {
                        RotateLR(parent);
                    }
                }
                break;                    //旋转完成后树恢复平衡
            }
        }
        return true;
    } 

    bool Remove(const K& key)
    {
        Node* parent = NULL;
        Node* cur = _root;
        Node* del = NULL;       //指向要删除的位置
        while (cur)
        {
            if (cur->_key < key)
            {
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                cur = cur->_left;
            }
            else
                break;
        }
        if (cur == NULL)      //无此节点，删除失败
        {
            return false;
        }
        del = cur;
        //如果要删除的结点有两个孩子，则需要找到右子树的最左结点
        if (cur->_left != NULL && cur->_right != NULL)
        {
            cur = cur->_right;
            while (cur->_left)
            {
                cur = cur->_left;
            }
            del->_key = cur->_key;
            del->_value = cur->_value;
            del = cur;                //交换之后使del指向要删除的结点
        }
        parent = cur->_parent;         //找到要删除结点的父亲
        if (cur->_left == NULL)        //要删除结点的左孩子为空，或者都为空
        {
            if (parent == NULL)       //要删除的是头结点
            {
                _root = cur->_right;
                if (cur->_right)
                {
                    cur->_right->_parent = NULL;
                }
            }
            else
            {
                if (parent->_left == cur)
                {
                    parent->_left = cur->_right;
                }
                else
                {
                    parent->_right = cur->_right;
                }
                if (cur->_right)
                {
                    cur->_right->_parent = parent;
                }
            }
            cur = del->_right;         //cur更新到要删除节点的右子树
        }
        else                          //要删除节点的右孩子为空，左孩子不为空
        {
            if (parent == NULL)        //要删除的是头结点
            {
                _root = cur->_left;
                if (cur->_left)
                {
                    cur->_left->_parent = NULL;
                }
            }
            else
            {
                if (parent->_left == cur)
                {
                    parent->_left = cur->_left;
                }
                else
                {
                    parent->_right = cur->_left;
                }
                if (cur->_left)
                {
                    cur->_left->_parent = parent;
                }
            }
            cur = del->_left;          //cur更新到要删除结点的左子树
        }
        //因为要删除的结点之后的子树的高度不变，不需修改，需要从parent向上判断是否平衡
        while (parent)
        {
            //调整parent的平衡因子
            if (parent->_left == cur)           //删除的是parent的左子树
            {
                parent->_bf++;
            }
            else
            {
                parent->_bf--;
            }
            if (parent->_bf == 1 || parent->_bf == -1)    //原来平衡，删除一个后高度不变，整棵树已经平衡
            {
                break;
            }
            //平衡因子原来不为0，删除一个后变为0，需要继续向上寻找
            if (parent->_bf != 0)
            {
                if (cur == NULL)
                {
                    if (parent->_left == NULL)
                    {
                        cur = parent->_right;
                    }
                    else
                    {
                        cur = parent->_left;
                    }
                }
                else
                {
                    if (parent->_left == cur)          //原来parent比较矮的左子树被删除，让cur指向较高的子树
                    {
                        cur = parent->_right;
                    }
                    else
                    {
                        cur = parent->_left;
                    }
                }
                if (cur->_bf == 0)                   //但旋转就可以实现平衡
                {
                    if (parent->_bf < 0)             //左子树高，进行右单旋
                    {
                        RotateR(parent);
                        parent->_bf = 1;
                        parent->_right->_bf = -1;
                    }
                    else                            //右子树高，进行左单旋
                    {
                        RotateL(parent);
                        parent->_bf = -1;
                        parent->_left->_bf = 1;
                    }
                    break;
                }
                //如果parent与较高子树同号，进行单旋
                int d = parent->_bf - cur->_bf;
                if (d == 1 || d == -1)
                {
                    if (d == 1)                    //右子树高，进行左单旋
                    { 
                        RotateL(parent);
                    }
                    else                          //左子树高，进行右单旋
                    {
                        RotateR(parent);
                    }
                }
                else                              //不同号，进行双旋
                {
                    if (d == 3)
                    {
                        RotateRL(parent);          //parent的平衡因子2，cur的平衡因子为-1，进行右左双旋
                    }
                    else
                    {
                        RotateLR(parent);          //parent的平衡因子-2，cur的平衡因子为1，进行左右双旋
                    }
                }
            }
            cur = parent;
            parent = parent->_parent;
        }
        delete del;
        return true;
    }

    bool Find(const K& key)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key < key)
            {
                cur = cur->_right;
            }
            else if (cur->_key > key)
            {
                cur = cur->_left;
            }
            else
            {
                return true;
            }
        }
        return false;
    }

    //判断一颗搜索二叉树是不是AVL树，要求将时间优化到O(N).
    //思路：从根节点向上开始判断，并将高度传回上一层。
    bool IsBalance()
    {
        int height = 0;
        return _IsBalance(_root, height);
    }

    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

protected:
    void _Copy(Node* root, Node*& new_root)
    {
        if (root == NULL)
        {
            return;
        }
        Node* node = new Node(root->_key, root->_value);
        node->_bf = root->_bf;
        new_root = node;
        node->_parent = new_root;
        _Copy(root->_left, new_root->_left);
        _Copy(root->_right, new_root->_right);
    }
    void _Destory(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _Destory(root->_left);
        _Destory(root->_right);
        delete root;
    }
    void _InOrder(Node* root)
    {
        if (root == NULL)
        {
            return;
        }
        _InOrder(root->_left);
        cout << root->_key << " ";
        _InOrder(root->_right);
    }
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        Node* ppNode = parent->_parent;

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

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

        if (parent == _root)
        {
            _root = subR;
            _root->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                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;
        Node* ppNode = parent->_parent;

        parent->_left = subLR;              //改变指向
        if (subLR)
        {
            subLR->_parent = parent;
        }
        subL->_right = parent;
        parent->_parent = subL;

        if (ppNode == NULL)
        {
            _root = subL;
            _root->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }
            subL->_parent = ppNode;
        }
        parent->_bf = subL->_bf = 0;         //更新平衡因子
    }
    void RotateRL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        int bf = subRL->_bf;

        RotateR(parent->_right);
        RotateL(parent);

        if (bf == 0)
        {
            parent->_bf = subR->_bf = subRL->_bf = 0;
        }
        else if (bf == 1)
        {
            subR->_bf = 0;
            subRL->_bf = 0;
            parent->_bf = -1;
        }
        else if (bf == -1)
        {
            subR->_bf = 1;
            subRL->_bf = 0;
            parent->_bf = 0;
        }
        else
        {
            assert(false);
        }
    }
    void RotateLR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        int bf = subLR->_bf;

        RotateL(parent->_left);
        RotateR(parent);

        if (bf == 0)
        {
            parent->_bf = subL->_bf = subLR->_bf = 0;
        }
        else if (bf == 1)
        {
            subL->_bf = -1;
            subLR->_bf = 0;
            parent->_bf = 0;
        }
        else if (bf == -1)
        {
            subL->_bf = 0;
            subLR->_bf = 0;
            parent->_bf = 1;
        }
        else
        {
            assert(false);
        }
    }
    bool _IsBalance(Node* root, int& height)
    {
        if (root == NULL)
        {
            height = 0;
            return true;
        }
        int leftHeight = 0;
        int rightHeight = 0;
        if (_IsBalance(root->_left, leftHeight) && _IsBalance(root->_right, rightHeight))
        {
            if (rightHeight - leftHeight != root->_bf)
            {
                cout << "平衡因子异常" << root->_key << endl;
                return false;
            }
            height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
            return abs(leftHeight - rightHeight) < 2;
        }
        else
        {
            return false;
        }
    }
private:
    Node* _root;
};

void TestAVLTree()
{
    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);
        cout << a[i] << ":" << t.IsBalance() << endl;
    }
    t.InOrder();
    cout << t.IsBalance() << endl;
    cout << t.Find(3) << endl;
    t.Remove(15);
    t.InOrder();
    cout << t.IsBalance() << endl;
}
adorable_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#，自平衡二叉查找树（AVL Tree）的算法与源代码
03-24
各种数据结构、算法及实用的C#源代码 C#，自平衡二叉查找树（AVL Tree）的算法与源代码 自平衡二叉查找树（AVL Tree）中任何节点的...也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。
（五）平衡多路查找树（B-Tree B+Tree）
kaka
06-30 9208
B-tree就是我们常说的B树，常常用于实现数据库索引，因为它的查找效率比较高 前面提到的2-3树可以看作B树的一种实例 一.为什么不用二叉搜索树用B树？ 二叉查找树的时间复杂度是O（logN），查找次数和比较次数较少，但是对于磁盘的IO次数，最坏情况下磁盘的IO次数由树的高度决定，所以减少磁盘IO次数就必须压缩树的高度，让瘦高的树尽量变成矮胖的树，这样B树就诞生了 二.B-...
【算法导论】最优二叉搜索树
编程小霸王的Blog
12-29 1万+
最优二叉搜索树       假定设定一个程序，实现英语文本到法语的翻译。对英语文本中出现的灭个单词，我们需要查找对应的法语单词。为了实现这些查找槽，我们可以创建一棵二搜索叉树，将n个英语单词作为关键词，对应的法语单词作为关联数据。由于文本中的每个单词都要进行搜索，我们希望花费在搜索上的总时间尽量减少。通过红黑树或其他平衡搜索树结构，我们可以假定每次搜索时间为O(lgn)，但是，单词出现的频率是不
动态规划之最优二叉搜索树
qeesung的专栏
04-20 6315
我们在之前也讨论过动态规划的例子： 动态规划原理：http://blog.csdn.net/ii1245712564/article/details/45040037 钢条切割问题：http://blog.csdn.net/ii1245712564/article/details/44464689 矩阵链乘法问题：http://blog.csdn.net/ii1245712564/arti
【二叉树进阶】AVLTree - 平衡二叉搜索树
codewinter的博客
06-20 2414
二叉搜索树的插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的效率。但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度为O(N)，因此 map、set 等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡二叉搜索树来实现。最优情况下，有 n 个结点的二叉搜索树为完全二叉树，查找效率为：O(log2N)最差情况下，有 n 个结点的二叉搜索树退化为单支树，查找效率为：O(N)平衡二叉搜索树（Self-balancing binary s
高度平衡二叉搜索树（AVLTree）
qq_49613557的博客
11-15 3306
高度平衡搜索二叉树（AVLTree） 目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋左右双旋右左双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，
avlTree:通用AVL树数据结构
06-18
在计算机科学中， AVL 树（Georgy Adelson-Velsky 和 ​​Landis 的树，以发明者的名字命名）是一种自平衡二叉搜索树。 这是第一个被发明的数据结构。 在AVL树中，任何节点的两个子子树的高度最多相差1； 如果在任何...
AVLTree实现的源代码
04-12
涉及如何构建平衡二叉树，是C语言源代码，最流行的算法
Lab7_AVLTree
03-26
AVL实验室目的本实验的重点是自平衡二进制搜索树。背景在计算机科学中，AVL树是一种自平衡二进制搜索树，它是第一个发明的此类数据结构。 在AVL树中，任何节点的两个子树的高度最多相差一个。 在平均和最坏情况下，...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
C++实现简单五子棋游戏
热门推荐
adorable_的博客
05-12 6万+
  五子棋是世界智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏，是世界智力运动会竞技项目之一，通常双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成5子连线者获胜。 规则 （1）对局双方各执一色棋子。 （2）空棋盘开局。 （3）黑先、白后，交替下子，每次只能下一子。 （4）棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处...
C++实现String
adorable_的博客
04-17 1038
浅拷贝 深拷贝 总结：浅拷贝只是对指针的拷贝，拷贝后两个指针指向同一个内存空间，深拷贝不但对指针进行拷贝，而且对指针指向的内容进行拷贝，经深拷贝后的指针是指向两个不同地址的指针。 String.h #pragma once #include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;string....
实现一个不能被继承的类
adorable_的博客
04-27 982
方法一：类对象的构造是通过构造函数实现的，如果将构造函数声明为私有或者保护类型，那么在类外是不能调用构造函数的，也就不能在类定义出对象。对此，我们可以在类里定义一个公有的接口返回成员函数生成的对象，之后在类外定义类时，只需调用这个函数即可 ，但这样还有缺陷，因为在类外只能通过类的对象来调用这个成员函数，所以应将这个接口声明为静态的。
C++知识体系框图
adorable_的博客
06-09 866
C++知识体系框图： 函数重载：https://blog.csdn.net/adorable_/article/details/79511025 引用与指针：https://blog.csdn.net/adorable_/article/details/79550133 类&amp;对象：https://blog.csdn.net/adorable_/article/details/79...
日期类之运算符重载
adorable_的博客
03-26 825
运算符重载
C++实现双向链表
adorable_的博客
04-26 792
C++实现双向链表
关于C语言与C++中函数重载问题
adorable_的博客
03-10 735
1.函数重载定义   函数重载：函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。重载函数通常用来命名一组功能相似的函数，这样做减少了函数名的数量，避免了名字空间的污染，对于程序的可读性有很大的好处。
C++实现动态顺序表
adorable_的博客
04-25 698
C++实现动态顺序表
内存池
adorable_的博客
08-08 468
内存池概念    通常我们用new和malloc来分配内存的话，由于申请的大小不确定，所以频繁的使用时会带来内存碎片和效率降低的问题。为了克服这种问题提出了内存池的概念。内存池是一种内存分配方式。内存池的优点是可以有效的减少内存碎片化，分配内存更加快速，减少内存泄漏等优点。    内存池是在真正使用内存之前，先申请分配一个大的内存块留作备用。当真正需要使用内存的时候，就从内存池中分配一...
数据结构二叉搜索树avl树
最新发布
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左...AVL树则是一种自平衡的二叉搜索树，它保证任何节点的左右子树高度差不超过1，因此能够保证树的查找、插入、删除等操作的时间复杂度为O(logN)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值