AVL树

学习了一下AVL树，参考资料详见<<数据结构与算法分析C++描述>>，只是实现了一下代码。。。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;

struct AvlNode
{
    int element;
    AvlNode *left;
    AvlNode *right;
    int height;
    AvlNode(const int &theElement, AvlNode *lt, AvlNode *rt, int h = 0)\
            : element(theElement), left(lt), right(rt), height(h) {}
};

class AvlTree
{
    public:
        AvlNode *root;
        AvlTree() : root(NULL) {}
        ~AvlTree() { clear(root); }
        bool empty(AvlNode *t);
        void clear(AvlNode * & t);
        int height(AvlNode *t);
        //AvlNode* get_root() { return this->root; }
        AvlNode* findMin(AvlNode *t);
        AvlNode* findMax(AvlNode *t);
        void display(AvlNode *t);
        void rotateWithLeftChild(AvlNode * & k2);
        void rotateWithRightChild(AvlNode * & k2);
        void doubleWithLeftChild(AvlNode * & k3);
        void doubleWithRightChild(AvlNode * & k3);
        void insert(const int &x, AvlNode * & t);
        void remove(const int &x, AvlNode * & t);
};

bool AvlTree::empty(AvlNode *t)
{
    return NULL == t;
}

void AvlTree::clear(AvlNode *&t)
{
    while(!empty(t))
    {
        remove(t->element, t);
    }
    return ;
}

int AvlTree::height(AvlNode *t)
{
    return NULL == t ? -1 : t->height;
}

AvlNode* AvlTree::findMin(AvlNode *t)
{
    if(NULL == t)
        return NULL;
    if(NULL == t->left)
        return t;
    return findMin(t->left);
}

AvlNode* AvlTree::findMax(AvlNode *t)
{
    if(NULL == t)
        return NULL;
    if(NULL == t->right)
        return t;
    return findMax(t->right);
}

void AvlTree::display(AvlNode *t)
{
    if(NULL == t)
        return ;
    display(t->left);
    cout << t->element << " ";
    display(t->right);
    return ;
}

void AvlTree::rotateWithLeftChild(AvlNode * & k2)
{
    AvlNode *k1 = k2->left;
    k2->left = k1->right;
    k1->right = k2;

    k2->height = max(height(k2->left), height(k2->right)) + 1;
    k1->height = max(height(k1->left), k2->height) + 1;
    k2 = k1;
    return ;
}

void AvlTree::rotateWithRightChild(AvlNode * & k2)
{
    AvlNode *k1 = k2->right;
    k2->right = k1->left;
    k1->left = k2;

    k2->height = max(height(k2->left), height(k2->right)) + 1;
    k1->height = max(k2->height, height(k1->right)) + 1;
    k2 = k1;
    return ;
}

void AvlTree::doubleWithLeftChild(AvlNode * & k3)
{
    rotateWithRightChild(k3->left);
    rotateWithLeftChild(k3);

    return ;
}

void AvlTree::doubleWithRightChild(AvlNode * & k3)
{
    rotateWithLeftChild(k3->right);
    rotateWithRightChild(k3);

    return ;
}

void AvlTree::insert(const int &x, AvlNode * & t)
{
    if(NULL == t)
        t = new AvlNode(x, NULL, NULL);
    else if(x < t->element)
    {
        insert(x, t->left);
        if(height(t->left) - height(t->right) == 2)
        {
            if(x < t->left->element)
            {
                rotateWithLeftChild(t);
            }
            else
            {
                doubleWithLeftChild(t);
            }
        }
    }
    else
    {
        insert(x, t->right);
        if(height(t->right) - height(t->left) == 2)
        {
            if(t->right->element < x)
            {
                rotateWithRightChild(t);
            }
            else
            {
                doubleWithRightChild(t);
            }
        }
    }
    t->height = max(height(t->left), height(t->right)) + 1;
    return ;
}

void AvlTree::remove(const int &x, AvlNode * & t)
{
    if(NULL == t)
        return;
    else if(x < t->element)
    {
        remove(x, t->left);
        if(height(t->right) - height(t->left) == 2)
        {
            AvlNode *rt = t->right;
            if(height(rt->right) > height(rt->left))
            {
                rotateWithRightChild(t);
            }
            else
            {
                doubleWithRightChild(t);
            }
        }
        else
        {
            t->height = max(height(t->left), height(t->right)) + 1;
        }
    }
    else if(t->element < x)
    {
        remove(x, t->right);
        if(height(t->left) - height(t->right) == 2)
        {
            AvlNode *lt = t->left;
            if(height(lt->left) > height(lt->right))
            {
                rotateWithLeftChild(t);
            }
            else
            {
                doubleWithLeftChild(t);
            }
        }
        else
        {
            t->height = max(height(t->left), height(t->right)) + 1;
        }
    }
    else
    {
        if(NULL != t->left && NULL != t->right)
        {
            if(height(t->left) > height(t->right))
            {
                t->element = findMax(t->left)->element;
                remove(t->element, t->left);
            }
            else
            {
                t->element = findMin(t->right)->element;
                remove(t->element, t->right);
            }
        }
        else
        {
            AvlNode *tt = t;
            t = (NULL == t->left ? t->right : t->left);
            delete tt;
            tt = NULL;
        }
    }
    return ;
}