AVL树（数据结构与算法分析代码）

AVL树是带有平衡条件的二叉查找树。

一棵AVL树是其每个结点的左右子树和右子树的高度最多差1的二叉查找树。（空树的高度定义为-1）。

AVL树是通过单旋转或者双旋转保持平衡性质。

PS：只是贴上代码（严格来说是保存代码。。。。），日后会贴上图片，方便理解。。。。。。。。

#include<iostream>
using namespace std;

template <typename Object>
class AVLTree
{
private:
    struct AVLNode
    {
        Object data;
        AVLNode * left;
        AVLNode * right;
        int height;

        AVLNode( const Object & d = Object(), AVLNode *l = NULL , AVLNode *r = NULL, int h = 0)
            : data( d ), left( l ), right( r ), height( h )
        { }
    };


public:
    AVLTree( )
    {
        root = NULL;
    }

    AVLTree( const AVLTree & rhs )
    {
        root = rhs.root;
    }
    ~AVLTree( )
    {
        makeEmpty( );
    }

    bool isEmpty( ) const
    {
        if( root == NULL )
            return true;
        else
            return false;
    }


    const Object & findMin( ) const
    {
        return findMin( root );
    }

    const Object & findMax( ) const
    {
        return findMax( root );
    }

    bool contains( const Object & x ) const
    {
        return contains( x, root );
    }

    void insert( const Object  & x )
    {
        insert( x, root );
    }

    void remove( const Object & x )
    {
        remove( x, root );
    }

    void makeEmpty( )
    {
        makeEmpty( root );
    }

    void preRecursive( )
    {
        preRecursive( root );
    }

private:
    AVLNode * root;

    int height( AVLNode * t ) const
    {
        //return t == NULL ? -1 : t->height;
        if(t == NULL)
            return -1;

        return t->height;
    }

    AVLNode * findMin( AVLNode * t ) const
    {
        if( t == NULL )
            return NULL;
        if( t->left == NULL )
            return t;
        return findMin( t->left );
    }

    AVLNode * findMax( AVLNode * t ) const
    {
        if( t == NULL )
            return NULL;
        if( t->right == NULL )
            return t;
        return findMax( t->right );
    }

    bool contains ( const Object & x, AVLNode * t ) const
    {
        if( t == NULL )
            return false;
        else if( x < t->data )
            return contains( x, t->left );
        else if( x > t->data )
            return contains( x, t->right );
        else
            return true;
    }

    void insert( const Object & x, AVLNode * & t )
    {
        if( t == NULL )
        {
            t = new AVLNode( );
            t->data = x;
            t->left = t->right = NULL;

            t = new AVLNode( x, NULL, NULL );
        }

        else if ( x < t->data )
        {
            insert( x, t->left );
            if( height( t->left ) - height( t->right ) == 2 )
            {
                if( x < t->left->data )
                    rotateWithLeftChild( t );
                else
                    doubleWithLeftChild( t );
            }
        }

        else if ( x > t->data )
        {
            insert( x, t->right );
            if( height( t->right) - height( t->left ) == 2 )
            {
                if( x > t->right->data )
                    rotateWithRightChild( t );
                else
                    doubleWithRightChild( t );
            }
        }

        else
            ;

        t->height = max( height( t->left ), height( t->right ) ) + 1;
    }

    void rotateWithLeftChild( AVLNode * & x )
    {
        AVLNode * y = x->left;
        x->left = y->right;
        y->right = x;
        x->height = max( height(x->left), height(x->right) ) + 1;
        y->height = max( height(y->left), x->height ) + 1;
        x = y;
    }

    void rotateWithRightChild( AVLNode * & x )
    {
        AVLNode * y = x->right;
        x->right = y->left;
        y->left = x;
        x->height = max( height(x->left), height(x->right) ) + 1;
        y->height = max( height(y->right), x->height ) + 1;
        x = y;
    }

    void doubleWithLeftChild( AVLNode * & x )
    {
        rotateWithRightChild(x->left);
        rotateWithLeftChild(x);
    }

    void doubleWithRightChild( AVLNode * & x )
    {
        rotateWithLeftChild(x->right);
        rotateWithRightChild(x);
    }

    void remove( const Object & x, AVLNode * & t ) const
    {
        if( t == NULL )
            return ;
        if( x < t->data )
            remove( x, t->left );
        else if( x > t->data )
            remove( x, t->right );
        else if( t->left != NULL && t->right != NULL )
        {
            t->data = findMin( t->right )->data;
            remove( t->data, t->right );
        }
        else
        {
            AVLNode * oldNode = t;
            t = ( t->left != NULL ) ? t->left : t->right;
            delete oldNode;
        }
    }

    void makeEmpty( AVLNode * & t ) const
    {
        if( t != NULL )
        {
            makeEmpty( t->left );
            makeEmpty( t->right );
            delete t;
        }
        t = NULL;
    }

    void preRecursive( AVLNode * &T ) const
    {
        if( T != NULL )
        {
            cout << T->data << " ";
            preRecursive( T->left );
            preRecursive( T->right );
        }
    }

};

int main()
{
    AVLTree<int> tree;
    int n, m;
    cin >> n;
    cout << endl;
    for(int i = 1; i <= n; ++i)
    {
        cin >> m;
        tree.insert( m );
        //tree.preRecursive();
        //cout << endl;
    }
    tree.preRecursive();
    /*tree.insert(7);
    tree.insert(13);
    tree.insert(3);
    tree.insert(2);
    tree.preRecursive();*/
    return 0;
}