平衡二叉树的实现

转载自http://www.cppblog.com/cxiaojia/archive/2012/08/20/187776.html
但是由于原文的代码有错，评论区很多人表示代码有误，跑不通
我自己手打了一遍，并进行了完善，自己测试插入和删除都无误，查找很简单就没写。
第一步树的节点
这里相比于二叉排序树多了高度信息，来维护平衡性

//平衡二叉查找树节点
template<class T>
class AVLTreeNode{
public:
    T data;
    int hgt;//树高度
    unsigned int freq;
    AVLTreeNode<T> *left;
    AVLTreeNode<T> *right;
    AVLTreeNode():left(NULL), right(NULL), freq(1), hgt(0){}
};

第二步，平衡二叉树申明

//平衡二叉树申明
template<class T>
class AVL{
private:
    AVLTreeNode<T>* root;
    void InsertNode(AVLTreeNode<T>* &rootnode, T x);//插入
    int Height(AVLTreeNode<T>* rootnode);
    AVLTreeNode<T>* SingRotateL(AVLTreeNode<T>* &k2);//左左旋
    AVLTreeNode<T>* SingRotateR(AVLTreeNode<T>* &k2);//右右旋
    void DoubleRotateLR(AVLTreeNode<T>* &k3);//左右旋
    void DoubleRotateRL(AVLTreeNode<T>* &k2);//右左旋
    void InsubTree(AVLTreeNode<T>* rootnode);//中序遍历
    void DeleteNode(AVLTreeNode<T>* &rootnode, T x);//删除

public:
    int Max(int first, int second);
    void insert(T x);//插入
    void insub();
    void del(T x);
};

第三步两个简单的计算函数
这里的height函数，很好的解决了指针为NULL的情况，第一遍阅读作者博客时，觉得这个可以忽视，在实现过程中，才发现这个函数的真实用处。

template<class T>
int AVL<T>::Height(AVLTreeNode<T>* rootnode)
{
    if (rootnode != NULL)
        return rootnode->hgt;
    return -1;
}


template<class T>
int AVL<T>::Max(int first, int second)
{
    return first > second ? first : second;
}

第四步四种变换
原文作者在变换过程中丢失了根节点，再次做了完善

//左左情况下旋转
template<class T>
AVLTreeNode<T>* AVL<T>::SingRotateL(AVLTreeNode<T>* &k2)
{
    AVLTreeNode<T>* record = k2;
    AVLTreeNode<T>* k1;
    k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k1->hgt = Max(Height(k1->left), Height(k1->right)) + 1;
    k2->hgt = Max(Height(k2->left), Height(k2->right)) + 1;
    record = k1;
    return k1;
}
//右右情况下旋转
template<class T>
AVLTreeNode<T>* AVL<T>::SingRotateR(AVLTreeNode<T>* &k2)
{
    AVLTreeNode<T>* k1;
    k1 = k2->right;
    k2->right = k1->left;
    k1->left = k2;

    k1->hgt = Max(Height(k1->left), Height(k1->right)) + 1;
    k2->hgt = Max(Height(k2->left), Height(k2->right)) + 1;
    return k1;
}
//左右情况下旋转
template<class T>
void AVL<T>::DoubleRotateLR(AVLTreeNode<T>* &k3)
{
    k3->left=SingRotateR(k3->left);
    k3 = SingRotateL(k3);

}
//右左情况下旋转
template<class T>
void AVL<T>::DoubleRotateRL(AVLTreeNode<T>* &k3)
{
    k3->right = SingRotateL(k3->right);
    k3 = SingRotateR(k3);
}

第五步执行插入
原文作者在最后的高度计算中缺失了+1，可能会导致后面的平衡判断失误，具体没有测试，不过我这个测试没有问题。

//插入节点
template<class T>
void AVL<T>::InsertNode(AVLTreeNode<T>* &rootnode, T x)
{
    if (rootnode == NULL)//插入节点
    {
        rootnode = new AVLTreeNode<T>();
        rootnode->data = x;
        return;
    }
    else if (rootnode->data > x)//插入左子树
    {
        InsertNode(rootnode->left, x);
        if ((Height(rootnode->left) - Height(rootnode->right)) == 2)//由于插入，重新计算hgt
        {
            if (x < rootnode->left->data)
            {
                rootnode = SingRotateL(rootnode);
            }
            else
            {
                DoubleRotateLR(rootnode);
            }
        }
    }
    else if (rootnode->data < x)//插入右子树
    {
        InsertNode(rootnode->right, x);
        if ((Height(rootnode->right) - Height(rootnode->left)) == 2)
        {
            if (x > rootnode->right->data)
            {
                rootnode = SingRotateR(rootnode);
            }
            else
            {
                DoubleRotateRL(rootnode);
            }
        }
    }
    else
    {
        rootnode->freq++;
    }
    rootnode->hgt = Max(Height(rootnode->left), Height(rootnode->right)) + 1;由于插入，重新计算hgt
}
template<class T>
void AVL<T>::insert(T x)//插入
{
    InsertNode(root, x);
}

第六步 删除节点
这里同样注意高度计算问题，同时删除过程我理解时和插入相反，所以变换都是与对应的插入相反

template<class T>
void AVL<T>::DeleteNode(AVLTreeNode<T>* &rootnode, T x)
{
    if (rootnode == NULL) return;
    if (rootnode->data > x)
    {
        DeleteNode(rootnode->left, x);
        if ((Height(rootnode->right) - Height(rootnode->left)) == 2)
        {
            if (rootnode->right->left != NULL && Height(rootnode->right->left) > Height(rootnode->right->right))
            {
                DoubleRotateRL(rootnode);
            }
            else
            {
                rootnode = SingRotateR(rootnode);
            }
        }
    }
    else if (rootnode->data < x)
    {
        DeleteNode(rootnode->right, x);
        if ((Height(rootnode->left) - Height(rootnode->right)) == 2)
        {
            if (rootnode->left->right != NULL && Height(rootnode->left->right) > Height(rootnode->left->left))
            {
                DoubleRotateLR(rootnode);
            }
            else
            {
                rootnode = SingRotateL(rootnode);
            }
        }
    }
    else
    {
        if (rootnode->left && rootnode ->right)
        {
            AVLTreeNode<T> * temp = rootnode->right;
            while (temp->left!= NULL)
            {
                temp = temp->left;
            }
            rootnode->data = temp->data;
            rootnode->freq = temp->freq;
            DeleteNode(rootnode->right, temp->data);
            if ((Height(rootnode->left) - Height(rootnode->right)) == 2)
            {
                if (rootnode->left->right != NULL && Height(rootnode->left->right) > Height(rootnode->left->left))
                    DoubleRotateLR(rootnode);
                else
                    rootnode = SingRotateL(rootnode);
            }
        }
        else
        {
            AVLTreeNode<T> * temp = rootnode;
            if (rootnode->left == NULL)
            {
                rootnode = rootnode->right;
            }
            else if (rootnode->right == NULL)
                rootnode = rootnode->left;
            delete temp;
        }
    }

    if (rootnode == NULL)return;
    rootnode->hgt = Max(Height(rootnode->left), Height(rootnode->right)) + 1;
    return;
}
template<class T>
void AVL<T>::del(T x)
{
    DeleteNode(root, x);
}

简单的先序遍历

template<class T>
void AVL<T>::insub()
{
    InsubTree(root);
}

template<class T>
void AVL<T>::InsubTree(AVLTreeNode<T>* rootnode)
{
    if (rootnode == NULL) return;
    InsubTree(rootnode->left);
    cout << rootnode->data << "\t";
    InsubTree(rootnode->right);
}

先这么多，自己测试插入和删除都没有问题。后续根据自己的理解在加一些注释，同时实现非递归版本。

最后运行结果展示