树 -- AVL树

前言

---

　　通过之前对二叉查找树的讨论,我们知道在给定节点数目的情况下,二叉树的高度越低,查找所用时间也就越短.

　　在讨论红黑树的时候,我们说过红黑树并非完全"平衡"的二叉树,只是近似"平衡".那么这个平衡到底指的是什么呢?有没有完全"平衡"的二叉树?

平衡二叉树

---

　　什么样的二叉树能被形容为平衡二叉树呢? 

　　　　1)空树

　　　　2)根的左右子树的高度之差的绝对值不超过1，并且左右子树也都是一棵平衡二叉树。

　　这样的树就被我们认作时平衡二叉树.

　　显然,当一颗二叉搜索树能够保证上面的性质时,树整体的高度就能得到良好的控制.

　　　

二叉树失衡

---

　　既然我们已经知道了平衡二叉树的定义,并且了解到了它的诸多好处.那么如何将一颗二叉搜索树构建成平衡二叉搜索树呢? (我们首先约定,叶子节点的高度为1.NULL节点的高度为0.)

　　首先让我们分析一下插入和删除操作中,二叉搜索树"失衡"后的状态.如下图所示:

　　

　　我们在2的左边插入了新的节点3后,使得对于1来讲,其左子树高度为2,右子树高度为1.进入了失衡的状态.

　　概括的讲,如果将平衡二叉树上某个节点的较高子树(比另一颗子树的高度大1)再增加1的高度,或者将某个节点的较低子树(比另一颗子树的高度小1)再减小1的高度,就会产生二叉树的失衡.

　　下面列举一下失衡的状态.

　　 --泛型>因为是1左侧的左侧的节点造成的失衡,所以称为LL失衡.

　　　--泛型>与LL失衡对称的RR失衡.

　　--泛型>因为是1左侧的右侧的节点造成的失衡,所以成为LR失衡.

　　--泛型>与LR失衡对称的RL失衡.

　　

失衡二叉树的恢复操作

---

　　在红黑树中,我们对于失衡的调整是根据节点的颜色,进行旋转和赋值操作来保证一种"近似的平衡".

　　那么对于一颗要保证"平衡的"的二叉树,该如何调整呢?我们分情况讨论一下.

1)LL失衡与LR失衡

　　对于某处的LL失衡,需要进行右旋操作,化解此处的失衡.然后向上查看是否还存在其他类型的失衡.

　　

　　对于RR失衡的修正类似于LL失衡的处理,旋转的方向改变成了左旋.

　　

template<class T>
TNode<T>* AvlTree<T>::__leftleftRotate(TNode<T> *dest){                                        
    assert(dest!=nil || dest->left!=nil);

    TNode<T> *l = dest->left;
    dest->left = l->right;
    l->right = dest;

    dest->height = __maxHeight(dest->left,dest->right)+1;
    l->height = __maxHeight(l->left,l->right)+1;

    if(root == dest)
        root = l;
    return l;
}
template<class T>
TNode<T>* AvlTree<T>::__rightrightRotate(TNode<T> *dest){
    assert(dest!=0 || dest->right!=0);

    TNode<T> *r = dest->right;
    dest->right = r->left;//Between dest and new left
    r->left = dest;

    dest->height = __maxHeight(dest->left,dest->right)+1;
    r->height = __maxHeight(r->left,r->right)+1;

    if(root == dest)
        root = r;
    return r;
}

2) 对于LR失衡和RL失衡　　

　　对于LR失衡,我们需要先对2节点进行左旋操作,然后对1节点进行右旋操作.这样可以将1节点下的不平衡消除.之后需要向上查看是否有其他不平衡节点.

　　对于RL失衡的处理,与LR类似.

 　　

template<class T>
TNode<T>* AvlTree<T>::__leftrightRotate(TNode<T> *dest){
    __rightrightRotate(dest->left);
    return __leftleftRotate(dest);
}
template<class T>
TNode<T>* AvlTree<T>::__rightleftRotate(TNode<T> *dest){
    __leftleftRotate(dest->right);
    return __rightrightRotate(dest);                                                           
}

插入

---

　　能破坏一课平衡二叉树的操作为插入新节点,和删除已有节点.我们结合前面讲的平衡恢复方法来实现平衡二叉树的插入操作.　　

　　插入某个节点之后,可能会破坏插入所经过的路径上的节点的平衡度.所以需要回溯路径上节点当前的平衡性.这种场合十分适合递归的方法.

　　

template<class T>
TNode<T>* AvlTree<T>::__insert(T val,TNode<T> *curr){
    if(curr==nil){
        TNode<T> *in = new TNode<T>(val,nil,nil,1);                                            
        assert(in);
        if(nil == root)
            root = in;
        curr = in;
    }else if(curr->val > val){
        curr->left = __insert(val,curr->left);
        if(std::abs(height(curr->left)-height(curr->right))>1){
            if(val < curr->left->val){
                curr = __leftleftRotate(curr);
            }else{
                curr = __leftrightRotate(curr);
            }
        }
    }else if(curr->val < val){
        curr->right = __insert(val,curr->right);
        if(std::abs(height(curr->left)-height(curr->right))>1){
            if(val > curr->right->val){
                curr = __rightrightRotate(curr);
            }else{
                curr = __rightleftRotate(curr);
            }
        }
    }else{
        std::cout<<"Duplicate val !
"<<std::endl;
        assert(0);
    }
    curr->height = __maxHeight(curr->left,curr->right) + 1;
    return curr;                                                                               
}

删除

---

　　产出某个节点后带来的失衡就类似于在另一支上插入了一个节点而带来的失衡.

　　依然需要回溯路径上的节点.

　　

template<class T>
TNode<T>* AvlTree<T>::__erase(TNode<T> *dest,TNode<T> *currRoot){
    assert(dest);

    if(currRoot->val > dest->val){
        currRoot->left = __erase(dest,currRoot->left);

        if(std::abs(height(currRoot->left)-height(currRoot->right))>1){
            if(height(currRoot->right->right) > height(currRoot->right->left))
                currRoot = __rightrightRotate(currRoot);
            else
                currRoot = __rightleftRotate(currRoot);
        }
    }else if(currRoot->val < dest->val){
        currRoot->right = __erase(dest,currRoot->right);
        if(std::abs(height(currRoot->left)-height(currRoot->right)>1)){
            if(height(currRoot->left->left) > height(currRoot->left->right))
                currRoot = __leftleftRotate(currRoot);
            else
                currRoot = __leftrightRotate(currRoot);
        }
    }else{//currRoot->val == dest->val
        TNode<T> *replace;
        if(currRoot->left!=nil && currRoot->right!=nil){
            if(height(currRoot->left) > height(currRoot->right)){
                replace = predecessor(currRoot);
                currRoot->val = replace->val;
                currRoot->left = __erase(replace,currRoot->left);
            }else{
                replace = successor(currRoot);
                currRoot->val = replace->val;
                currRoot->right = __erase(replace,currRoot->right);
            }
        }else{
            replace = (currRoot->left!=nil)?currRoot->left:currRoot->right;
            delete dest;
            currRoot = replace;
        }
    }
    currRoot->height = ((currRoot==nil)?0:__maxHeight(currRoot->left,currRoot->right)+1);
    return currRoot;
}

参考

---

　　http://www.cnblogs.com/skywang12345/p/3603935.html