本文内容为前天写的AVL树模板的C++代码实现。本想把二叉搜索树设计成基类（SearchTree），然后由AVL树和红黑树分别对其继承，因为作为搜索树，它们在查找、插入和删除元素时都用到了相同的节点查找方法，因此这种继承机制可以很好地利用继承机制的优点。但是在类的具体实现时，却遇到了一些问题。

首先，我定义了二叉搜索树的树节点类：BTNode。它只是普通的二叉树节点：数据成员包括value和两个指针lchild、rchild分别指向左右孩子。但是这里的指针只能定义为指向基类（BTNode）的指针。然后定义了SearchTree类。该类没有自己的数据成员，仅为子类提供接口。共有两个虚函数：

virtual BTNode<T>* root_insert(const T& elem, BTNode<T> *root) ;

virtual BTNode<T>* root_find(const T& elem, BTNode<T> *root);

分别用于定位元素的父节点和定位元素。函数的参数以及返回值包含指向树节点的指针，在该类的实现中，指针也只能是指向基类（BTNode）节点的指针。

然后定义AVL树的节点类AVLTNode，继承BTNode，扩充了两个数据成员：指向父节点的指针parent（为派生类指针）和表示平衡因子的整数BF。

接下来定义了AVL树，数据成员为指向AVLTNode的指针root表示树根。问题就出现在AVLTree的实现中。在实现插入和删除时用到了基类的成员函数实现节点查找，找到的是指向基类节点的指针；节点的左右子节点指针均为指向基类的指针。在这里就需要用到大量的数据类型转换以实现指向基类的指针为指向派生类的指针的赋值。还好在这里我们可以保证AVL中的树节点均为派生类节点而不至于引起派生类指针指向基类对象所引发的不可预知的结果。下面的代码中可以发现大量的static_cast关键字，原因就在这里。。。为了减少static_cast的使用，可以再派生类中实现一个内联函数来实现。

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

以下就是具体的代码实现：

// BTNode类的定义

template<typename T> 

class BTNode
{
    public:
        BTNode():lchild(0), rchild(0){}
        BTNode(T elem):data(elem), lchild(0), rchild(0){}
        virtual ~BTNode()
        {
        }
    protected:
        BTNode<T> *lchild;
        BTNode<T> *rchild;
        T data;
    private:
        template<typename T1>
        friend class SearchTree;
        template <typename T1>
        friend class AVLTree;
};

// AVLTNode类的定义
template <typename T>
class AVLTNode : public BTNode<T>
{
    public:
        AVLTNode():parent(0), BF(0){}
        AVLTNode(T elem) : BTNode<T>(elem), parent(0), BF(0){}
        AVLTNode<T>* right_rotate();
        AVLTNode<T>* left_rotate();
    private:
        AVLTNode<T> *parent;
        int BF;
    private:
        template <typename T1>
        friend class AVLTree;
};
template <typename T>
AVLTNode<T>* AVLTNode<T>::right_rotate() // 右旋，仅实现了子树内部父子关系的改变以及BF值的更新，子树与外部节点之间的父子关系还未更新
{
    AVLTNode<T> *p(static_cast<AVLTNode<T>*>(this->lchild));
    if(!p)
    {
        return this;
    }
    this->lchild = p->rchild;
    if(p->rchild)
    {
        static_cast<AVLTNode<T>*>(p->rchild)->parent = this;
    }
    p->rchild = this;
    BF -= (p->BF > 0 ? 1 + p->BF : 1);
    p->BF -= (BF < 0 ? 1 - BF : 1);
    return p;
}
template <typename T>
AVLTNode<T>* AVLTNode<T>::left_rotate()
{
    AVLTNode<T> *p(static_cast<AVLTNode<T>*>(this->rchild));
    if(!p)
    {
        return this;
    }
    this->rchild = p->lchild;
    if(p->lchild)
    {
        static_cast<AVLTNode<T>*>(p->lchild)->parent = this;
    }
    p->lchild = this;
    BF += (p->BF < 0 ? 1 - p->BF : 1);
    p->BF += (BF > 0 ? 1 + BF : 1);
    return p;
}
template <typename T>
class SearchTree
{
    public:
        SearchTree() {}	
        virtual ~SearchTree() {}
    protected:
        virtual BTNode<T>* root_insert(const T& elem, BTNode<T> *root);
        virtual BTNode<T>* root_find(const T& elem, BTNode<T> *root);
    private:
};
template <typename T>
BTNode<T>* SearchTree<T>::root_insert(const T& elem, BTNode<T> *root)
{
    BTNode<T> *p(root);
    while(p)
    {
        root = p;
        p = (root->data < elem ? root->rchild : root->lchild);
    }
    return root;
}
template<typename T>
BTNode<T>* SearchTree<T>::root_find(const T& elem, BTNode<T> *root)
{
    while(root)
    {
        if(root->data == elem)
        {
            break;
        }
        else if(root->data < elem)
        {
            root = root->rchild;
        }
        else
        {
            root = root->lchild;
        }
    }
    return root;
}

// 以下为AVLTree模板的代码实现：

template <typename T>
class AVLTree : public SearchTree<T>
{
    public:
        AVLTree() : root(0) {}
        virtual ~AVLTree() {}
        virtual void insert(const T& elem);
        virtual void erase(const T& elem);
        virtual bool find(const T& elem);
    protected:
    private:
        AVLTNode<T> *root;
};

// 插入操作，也许会改变父节点的BF值，自新插入节点向上追溯并更新相应节点的BF值直到根节点，若某个节点BF变为2或-2，则需要旋转以达到平衡，且向上的追溯止于此。
template <typename T>
void AVLTree<T>::insert(const T& elem)
{
    AVLTNode<T> *p = static_cast<AVLTNode<T>*>(SearchTree<T>::root_insert(elem, root));
    AVLTNode<T> *node = new AVLTNode<T>(elem);
    node->parent = p;
    if(!p)
    {
        root = node;
        return;
    }
    
    if(p->data >= elem)
    {
        p->lchild = node;
    }
    else
    {
        p->rchild = node;
    }
    while(p)
    {
        if(node == p->lchild)
        {
            ++p->BF;
            if(p->BF == 0)
            {
                break;
            }
            if(p->BF == 2) 
            {
                if(node->BF == -1) 
                {
                    AVLTNode<T> *q = node->left_rotate();
                    q->parent = p;
                    node->parent = q;
                    p->lchild = q;
                    node = q;
                }
                node = p->right_rotate();
                node->parent = p->parent;
                p->parent = node;
                if(!node->parent)
                {
                    root = node;
                }
                else
                {
                    AVLTNode<T> *q = node->parent;
                    if(q->lchild == p)
                    {
                        q->lchild = node;
                    }
                    else
                    {
                        q->rchild = node;
                    }
                }
                break;
            }
            node = p;
            p = p->parent;
        }
        else
        {
            --p->BF;
            if(p->BF == 0)
            {
                break;
            }
            if(p->BF == -2)
            {
                if(node->BF == 1)
                {
                    AVLTNode<T> *q = node->right_rotate();
                    q->parent = p;
                    node->parent = q;
                    p->rchild = q;
                    node = q;
                }
                node = p->left_rotate();
                node->parent = p->parent;
                p->parent = node;
                if(!node->parent)
                {
                    root = node;
                }
                else
                {
                    AVLTNode<T> *q = node->parent;
                    if(q->lchild == p)
                    {
                        q->lchild = node;
                    }
                    else
                    {
                        q->rchild = node;
                    }
                }
                break;
            }
            node = p;
            p = p->parent;
        }
    }
}

// 删除操作，父节点的BF会变化，故同样需要向上追溯。若BF由非0变为0，则树高减小，继续向上追溯；否则停止追溯。
template <typename T>
void AVLTree<T>::erase(const T& elem)
{
    BTNode<T> *fp = SearchTree<T>::root_find(elem, root);
    if(!fp)
    {
        return;
    }
    BTNode<T> *fnode = fp->lchild;
    if(!fnode)
    {
        fnode = (fp->rchild ? fp->rchild : fp);
    }
    else
    {
        while(fnode->rchild)
        {
            fnode = fnode->rchild;
        }
    }
    fp->data = fnode->data;
    
    AVLTNode<T> *p = static_cast<AVLTNode<T>*>(fnode);
    AVLTNode<T> *q = p->parent;
    AVLTNode<T> *node = static_cast<AVLTNode<T>*>(p->lchild);
    if(root == p)
    {
        delete p;
        root = 0;
        return;
    }
    
    if(node)
    {
        node->parent = q;
    }
    bool Left(true);
    if(p == q->lchild)
    {
        q->lchild = node;
    }
    else
    {
        Left = false;
        q->rchild = node;
    }
    delete p;
    p = node;
    
    while(q)
    {
        if(Left)
        {
            int BF = --q->BF;
            if(BF == -1)
            {
                break;
            }
            else if(BF == -2)
            {
                node = static_cast<AVLTNode<T>*>(q->rchild);
                if(node->BF == 1)
                {
                    AVLTNode<T> *temp = node->right_rotate();
                    temp->parent = q;
                    node->parent = temp;
                    q->rchild = temp;
                }
                p = q->left_rotate();
                p->parent = q->parent;
                q->parent = p;
                node = p->parent;
                if(!node)
                {
                    root = p;
                    break;
                }
                if(q == node->lchild)
                {
                    node->lchild = p;
                }
                else
                {
                    node->rchild = p;
                }
                q = node;
            }
            else
            {
                p = q;
                q = q->parent;
            }
        }
        else
        {
            int BF =  ++q->BF;
            if(BF == 1)
            {
                break;
            }
            else if(BF == 2)
            {
                node = static_cast<AVLTNode<T>*>(q->lchild);
                if(node->BF == -1)
                {
                    AVLTNode<T> *temp = node->left_rotate();
                    temp->parent = q;
                    node->parent = temp;
                    q->lchild = temp;
                }
                p = q->right_rotate();
                p->parent = q->parent;
                q->parent = p;
                node = p->parent;
                if(!node)
                {
                    root = p;
                    break;
                }
                if(q == node->lchild)
                {
                    node->lchild = p;
                }
                else
                {
                    node->rchild = p;
                }
                q = node;
            }
            else
            {
                p = q;
                q = q->parent;
            }
        }
        if(q)
        {
            Left = (p == q->lchild);
        }
    }
}
template <typename T>
bool AVLTree<T>::find(const T& elem)
{
    return SearchTree<T>::root_find(elem, root) != NULL;
}