【数据结构】AVL树/红黑树

目录

1.AVL树（高度平衡二叉搜索树）

10.1.基本概念

10.2.实现

10.2.1.AVL树节点的定义

10.2.2.AVL树的插入

10.2.3.AVL树的旋转

1.新节点插入较高左子树的左侧---左左：右单旋

2.新节点插入较高右子树的右侧---右右：左单旋

3.新节点插入较高左子树的右侧---左右：先左单旋再右单旋（左右双旋）

4.新节点插入较高右子树的左侧---右左：先右单旋再左单旋（右左双旋）

10.2.4.AVL树的验证

10.2.5.AVL树的删除(了解)

10.2.6.AVL树的性能

2.红黑树

11.1.红黑树的概念

11.1.1.定义：

11.1.2.红黑树的性质

11.2.红黑树的实现

11.2.1.红黑树的结构

11.2.2.红黑树的插入操作

11.3红黑树的验证

11.4.红黑树的删除

11.5.红黑树与AVL树的比较

---

---

---

1.AVL树（高度平衡二叉搜索树）

10.1.基本概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landi在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)

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

10.2.实现

10.2.1.AVL树节点的定义

template<class T>
struct AVLTreeNode
{
 AVLTreeNode(const T& data)
     : _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
 , _data(data), _bf(0)
 {}
 AVLTreeNode<T>* _pLeft;   // 该节点的左孩子
 AVLTreeNode<T>* _pRight;  // 该节点的右孩子
 AVLTreeNode<T>* _pParent; // 该节点的双亲
 T _data;
 int _bf;                  // 该节点的平衡因子
};

10.2.2.AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么

AVL树的插入过程可以分为两步：

1. 按照二叉搜索树的方式插入新节点
2. 调整节点的平衡因子,并检查是否平衡（不平衡需要调节）

template<class T>
class AVLTree
{
    typedef AVLTreeNode Node;
    AVLTree()
        :_root(nullptr)
    {}

    bool insert(const T& val)
    {
        //如果为空
        Node* newnode = new Node(val);
        if (_root == nullptr)
        {
            _root = newnode;
            _root->_df = 0;
            return true;
        }
// 1. 先按照二叉搜索树的规则将节点插入到AVL树中
        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {///寻找插入节点位置
            if (val > cur->_val) { parent = cur; cur = cur->_right; }
            else if (val < cur->_val) { parent = cur; cur = cur->_left; }
            else { return false; }
        }

        //插入节点并且修改指向
        if (val > parent->_val) { parent->_right = newnode; }
        else { parent->_left = newnode; }
        newnode->_parent = parent;
        cur = newnode;

// 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的平衡因子违反平衡树的性质，需要对其进行旋转处理
 */
        while (parent)
        {//更新平衡因子
            if (cur == parent->_left) { parent->_df--; }
            else { parent->_df++; }
            //并检测是否破坏了AVL树的平衡性
            if (parent->_df == 0) { break; }
            else if (parent->_df == 1 || parent->_df == -1) { 
                //向上调整
                cur = parent;
                parent = cur->_parent;
            }
            else if (parent->_df == 2 || parent->_df == -2) { 
                //平衡被打破，开始调节平衡（旋转）
                if (parent->_df == -2 && cur ->_df == -1 ) {
                    //新节点插入较高左子树的左侧---左左：右单旋
                    _RotateR(parent);
                }
                else if (parent ->_df == 2 && cur->_df == 1 ) {
                    //新节点插入较高右子树的右侧---右右：左单旋
                    _RotateL(parent);
                }
                else if (parent->_df == -2 && cur->_df == 1) {
                    //新节点插入较高左子树的右侧---左右：先左单旋再右单旋（左右双旋）
                    _RotateLR(parent);
                }
                else if (parent->_df == 2 && cur->_df == -1) {
                    //新节点插入较高右子树的左侧---右左：先右单旋再左单旋（右左双旋）
                    _RotateRL(parent);

                }
                else { assert(false); }
                return true;
            }
            else { assert(false); }    
        }
        return true;
    }

private:
    Node* _root;
};

10.2.3.AVL树的旋转

如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种：

1.新节点插入较高左子树的左侧---左左：右单旋

上图在插入前，AVL树是平衡的，新节点插入到30的左子树(注意：此处不是左孩子)中，30左子树增加了一层，导致以60为根的二叉树不平衡，要让60平衡，只能将60左子树的高度减少一层，右子树增加一层，即将左子树往上提，这样60转下来，因为60比30大，只能将其放在30的右子树，而如果30有右子树，右子树根的值一定大于30，小于60，只能将其放在60的左子树，旋转完成后，更新节点的平衡因子即可。

在旋转过程中，有以下几种情况需要考虑：

1. 30节点的右孩子可能存在，也可能不存在

2. 60可能是根节点，也可能是子树

如果是根节点，旋转完成后，要更新根节点

如果是子树，可能是某个节点的左子树，也可能是右子树

    void _RotateR(Node* parent)//右单旋
    {
        Node* grantparent = parent->_parent;
        Node* cur = parent->_left;
        Node* subr = cur->_right;

        cur->_right = parent;
        parent->_parent = cur;
        parent->_left = subr;
        if (subr) {//判断cur的右边是否为空
            //parent->_left = subr;//这个指向不能放在这里问什么？
            subr->_parent = parent;
        }

        if (grantparent ==  nullptr) {//判断parent是否是根节点
            _root = cur;//是根节点。
            cur->_parent = nullptr;
        }
        else {
            //parent 不是根节点
            //需要修改爷爷节点的指向
            if (grantparent->_left == parent){
                grantparent->_left = cur;
                cur->_parent = grantparent;
            }
            else{
                grantparent->_right = cur;
                cur->_parent = grantparent;
            }
        }
        //修改平衡因子
        cur->_df = parent->_df = 0;
    }

2.新节点插入较高右子树的右侧---右右：左单旋

    void _RotateL(Node* parent)//左单旋
    {
        Node* grantparent = parent->_parent;
        Node* cur = parent->_right;
        Node* subl = cur->_left;
        cur->_left = parent;
        parent->_parent = cur;

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

        if (grantparent == nullptr){
            //parent是根节点
            _root = cur;
            _root->_parent = nullptr;
        }
        else{
            if (grantparent->_left == parent){
                grantparent->_left = cur;
            }
            else{
                grantparent->_right = cur;
            }
            cur->_parent = grantparent;
        }
        //修改平衡因子
        cur->_df = parent->_df = 0;
    }

参考右单旋

3.新节点插入较高左子树的右侧---左右：先左单旋再右单旋（左右双旋）

将双旋变成单旋后再旋转，即：先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

// 旋转之前，60的平衡因子可能是-1/0/1，旋转完成之后，根据情况对其他节点的平衡因子进行调整  
    void _RotateLR(Node* parent)
    {
        Node* cur = parent->_left;
        Node* subr = cur->_right;
        int df = subr->_df;
        _RotateL(cur);
        _RotateR(parent);
        //单旋将平衡因子置为0，不满足要求
        //修改平衡因子
        //主要是修改 cur 和 parent 
        if (df == 1)
        {
            parent->_df = 0;
            cur->_df = -1;
            subr->_df = 0;
        }
        else if (df == -1)
        {
            cur -> _df = 0;
            parent->_df = 1;
            subr->_df = 0;
        }
        else if (df == 0)
        {
            cur->_df = 0;
            parent->_df = 0;
            subr->_df = 0;
        }
        else
        {
            assert(false);
        }
    }

4.新节点插入较高右子树的左侧---右左：先右单旋再左单旋（右左双旋）

 
    void _RotateRL(Node* parent)
    {
        Node* cur = parent->_right;
        Node* subl = cur->_left;
        int df = subl->_df;
        _RotateR(cur);
        _RotateL(parent);
        //修改平衡因子
        //主要是修改 cur 和 parent 
        if (df == 1)
        {
            parent->_df = -1;
            cur->_df = 0;
            subl->_df = 0;
        }
        else if (df == -1)
        {
            parent->_df = 0;
            cur->_df = 1;
            subl->_df = 0;
        }
        else if (df == 0)
        {
            cur->_df = 0;
            parent->_df = 0;
            subl->_df = 0;
        }
        else
        {
            assert(false);
        }
    }

总结：

假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑

1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR

当pSubR的平衡因子为1时，执行左单旋
当pSubR的平衡因子为-1时，执行右左双旋

2. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL

当pSubL的平衡因子为-1是，执行右单旋
当pSubL的平衡因子为1时，执行左右双旋

旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

10.2.4.AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

1. 验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

    void InOrder()
    {
        _inorder(_root);
        cout << endl;
    }
    void _inorder(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
        _inorder(root->_left);
        cout << root->_val << ' ';
        _inorder(root->_right);
    }

2. 验证其为平衡树

每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确

int _Height(Node* root)
{
    if (root == nullptr)
    {
        return 0;
    }
    int Hleft = 1+ _Height(root->_left);
    int Hright = 1+ _Height(root->_right);
    return Hleft > Hright ? Hleft : Hright;
}

bool _IsBalanceTree(Node* root)
{
    if (root == nullptr)
    {
        return true;
    }
    int Hleft = _Height(root->_left);
    int Hright = _Height(root->_right);
    int df = Hright - Hleft;
    if ((df == 0 || df == 1 || df == -1) && df == root->_df)
    {
        return _IsBalanceTree(root->_left) && _IsBalanceTree(root->_right);
    }
    else
    {
        cout <<"error:" << root->_val << endl;
        return false;
    }
}

bool IsBalanceTree()
{
    return _IsBalanceTree(_root);
}

10.2.5.AVL树的删除(了解)

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。具体实现可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

10.2.6.AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即$log_2 (N)$。

但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

//枚举结构
enum color
{
    RED,
    BLACK
};
template<class value_type>
struct RBTreeNode
{
    RBTreeNode(const value_type& val)
        :_left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _val(val)
        , _col(RED){ }

    RBTreeNode< value_type>* _left;
    RBTreeNode< value_type>* _right;
    RBTreeNode< value_type>* _parent;
    value_type _val;
    color _col;
};


template<typename value_type>
class RBTree
{
    typedef RBTreeNode<value_type> Node;
public:
    RBTree()
        :_root(nullptr) {}
///在这里实现增删改查 ///

private:
    Node* _root;
};

    bool insert(const value_type val)
    {
        //空树
        if (_root == nullptr)
        {
            _root = new Node(val);
            _root->_col = BLACK;
            return true;
        }
        
        Node* p = nullptr;//父亲节点
        Node* cur = _root;//当前节点
        while (cur)
        {
            if (val > cur->_val) { p = cur; cur = cur->_right; }
            else if (val < cur->_val) { p = cur; cur = cur->_left; }
            else { return false; }
        }
        //此时cur为空
        cur = new Node(val);
        if (val > p->_val) { p->_right = cur; }
        else { p->_left = cur; }
        cur->_parent = p;


        while (cur->_parent &&  cur != _root)//cur是新插入的节点
        {
            p = cur->_parent;

            //父亲节点是黑色直接插入完成。
            if (p->_col == BLACK) { return true; }
            //此时当前cur节点和parent节点都是红色
            //不满足红黑树的性质（不能有连续相同的红色节点）
            //此时就要看叔叔节点是什么了


            Node* g = p->_parent;//爷爷节点
            if (g == nullptr)
            {
                break;
            }
            Node* u = g->_left == p ? g->_right : g->_left; //叔叔节点
            if (u && u->_col == RED)
            {//情况一： 存在且为红色
                //直接修改颜色，继续向上调整即可
                g->_col = RED;
                p->_col = BLACK;
                u->_col = BLACK;
                cur = g;//把g看作新插入的节点继续向上调整。
                continue;
            }
            //走到这里要么u 是 黑 ，要么 不存在
            if (g->_left == p && p->_right == cur)
            {//情况三
                _RotateL(p);
                cur = p;//转化为情况二继续处理
                continue;
            }
            if (g->_right == p && p->_left == cur)
            {//情况三
                _RotateR(p);
                cur = p;//转化为情况二继续处理
                continue;
            }
            if (g->_left == p && p->_left == cur)
            {//情况二
                _RotateR(g);
                p->_col = BLACK;
                g->_col = RED;
                return true;//情况二处理完成后可以直接退出
            }
            if (g->_right == p && p->_right == cur)
            {//情况二
                _RotateL(g);
                p->_col = BLACK;
                g->_col = RED;
                return true;//情况二处理完成后可以直接退出
                //表明已经处理完成
            }
        }

        _root->_col = BLACK;
        return true;
    }


    void _RotateR(Node* parent)//右单旋
    {
        Node* grantparent = parent->_parent;
        Node* cur = parent->_left;
        Node* subr = cur->_right;

        cur->_right = parent;
        parent->_parent = cur;
        parent->_left = subr;
        if (subr) {//判断cur的右边是否为空
            //parent->_left = subr;//这个指向不能放在这里问什么？
            subr->_parent = parent;
        }

        if (grantparent == nullptr) {//判断parent是否是根节点
            _root = cur;//是根节点。
            cur->_parent = nullptr;
        }
        else {
            //parent 不是根节点
            //需要修改爷爷节点的指向
            if (grantparent->_left == parent) {
                grantparent->_left = cur;
                cur->_parent = grantparent;
            }
            else {
                grantparent->_right = cur;
                cur->_parent = grantparent;
            }
        }
    }



    void _RotateL(Node* parent)//左单旋转
    {
        Node* grantparent = parent->_parent;
        Node* cur = parent->_right;
        Node* subl = cur->_left;
        cur->_left = parent;
        parent->_parent = cur;

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

        if (grantparent == nullptr) {
            //parent是根节点
            _root = cur;
            _root->_parent = nullptr;
        }
        else {
            if (grantparent->_left == parent) {
                grantparent->_left = cur;
            }
            else {
                grantparent->_right = cur;
            }
            cur->_parent = grantparent;
        }
    }

    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }
    void _Inorder(const Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
        _Inorder(root->_left);
        cout << root->_val << ' ';
        _Inorder(root->_right);
    }

    bool IsRBTree()
    {
        //空树也是红黑树
        if (_root == nullptr){
            return true;
        }
        //根节点一定是黑
        if (_root->_col == RED) { 
            cout << "违反红黑树性质二：根节点必须为黑色" << endl; 
            return false; 
        }
        // 获取任意一条路径中黑色节点的个数
        int Blackcnt = 0;
        Node* cur = _root;
        while (cur)
        {
            if(cur->_col == BLACK)
            { 
                Blackcnt++;
            }
            cur = cur->_right;
        }
        // 检测是否满足红黑树的性质，k用来记录路径中黑色节点的个数
        int k = 0;
        return _IsRBTree(_root, k, Blackcnt);
    }
    bool _IsRBTree(Node* root, int k, int Blackcnt)
    {
        if (root == nullptr)
        {
            if (k == Blackcnt){
                return true;
            }
            else {
                cout << "违反性质四：每条路径中黑色节点的个数必须相同" << endl;
                return false;
            }
        }

        if (root->_col == BLACK)
            k++;

        Node* parent = root->_parent;
        if (parent && parent->_col == RED && root->_col == RED)
        {
            cout<< "违反性质三：没有连在一起的红色节点" << endl;
            return false;
        }
        return _IsRBTree(root->_left, k, Blackcnt) && _IsRBTree(root->_right, k, Blackcnt);
    }