AVL树

C实现代码如下：

    
    /*
      AVL树
    */
    
    /*接口头文件*/
    typedef int ElementType;
    
    #ifndef _AVLTREE_H
    #define _AVLTREE_H
    
    struct AVLNode;
    typedef struct AVLNode * PtrToNode;
    typedef PtrToNode Position;
    typedef PtrToNode AVLTree;
    
    /*操作集*/
    AVLTree MakeEmpty( AVLTree T );
    AVLTree Insert( ElementType X, AVLTree T );
    AVLTree Delete( ElementType X, AVLTree T );
    Position Find( ElementType X, AVLTree T );
    Position FindMin( AVLTree T );
    Position FindMax( AVLTree T );
    ElementType Retrieve( Position P );
    void PrintfTree( AVLTree T );
    
    #endif
    
    
    /*接口实现*/
    #include <stdio.h>
    #include <stdlib.h>
    #include "AVLTree.h"
    
    /*特定结构体定义*/
    struct AVLNode
    {
        ElementType Element;
        AVLTree     Left;
        AVLTree     Right;
        int         Height;
    };
    
    int Height( Position P );
    int Max( int A, int B );
    Position SingleRotateWithLeft( Position K1 );
    Position SingleRotateWithRight( Position K1 );
    Position DoubleRotateWithLeft( Position K1 );
    Position DoubleRotateWithRight( Position K1 ); 
    
    AVLTree
    MakeEmpty( AVLTree T )
    {
        if ( T != NULL )
        {
            MakeEmpty( T->Left );
            MakeEmpty( T->Right );
            MakeEmpty( T );
        }
        
        return NULL;
    }
    
    Position
    Find( ElementType X, AVLTree T )
    {
        if ( T == NULL )
            return NULL;
        if ( X < T->Element )
            return Find( X, T->Left );
        else
        if ( X > T->Right )
            return Find( X, T->Right );
        else
            return T;
    }
    
    /*递归例程*/
    Position
    FindMin( AVLTree T )
    {
        if ( T == NULL )
            return NULL;
        if ( T->Left == NULL )
            return T;
        else
            return FindMin( T->Left );
    }
    
    /*非递归例程*/
    /*
    Position
    FindMin( AVLTree T 0
    {
        if ( T != NULL )
            while ( T->Left != NULL )
                T = T->Left;
            
        return T;
    }
    */
    
    /*递归例程*/
    Position
    FindMax( AVLTree T )
    {
        if ( T == NULL )
            return NULL;
        if ( T->Right == NULL )
            return T;
        else
            return FindMax( T->Right );
    }
    
    /*非递归例程*/
    /*
    Position
    FindMax( AVLTree T )
    {
        if ( T != NULL )
            while ( T->Right 1= NULL )
                T = T->Right;
            
        return T;
    }
    */
    
    ElementType
    Retrieve( Position P )
    {
        return P->Element;
    }
    
    /*中序查找，打印*/
    void
    PrintfTree( AVLTree T )
    {
        if ( T != NULL )
        {
            PrintfTree( T->Left );
            printf( "%3d", T->Element );
            PrintfTree( T->Right );
        }
    }
    
    AVLTree
    Insert( ElementType X, AVLTree T )
    {
        if ( T == NULL )
        {
            T = ( AVLTree )malloc( sizeof( struct AVLNode ) );
            if ( T == NULL )
            {
                printf( "No Space!!!\n" );
                exit( 1 );
            }
            T->Element = X;
            T->Height = 0;
            T->Left = NULL;
            T->Right = NULL;
        }
        
        if ( X < T->Element )
        {
            T->Left = Insert( X, T->Left );
            if ( Height( T->Left ) - Height( T->Right ) == 2 )
            {
                if ( X < T->Left->Element )
                    T = SingleRotateWithLeft( T );
                else
                    T = DoubleRotateWithLeft( T );
            }
        }
        else
        if ( X > T->Element )
        {
            T->Right = Insert( X, T->Right );
            if ( Height( T->Right ) - Height( T->Left ) == 2 )
            {
                if ( X > T->Right->Element )
                    T = SingleRotateWithRight( T );
                else
                    T = DoubleRotateWithRight( T );
            }
        }
        
        T->Height = Max( Height( T->Left ), Height( T->Right ) ) + 1;
        
        return T;
    }
    
    int
    Max( int A, int B )
    {
        return A > B ? A : B;
    }
    
    int
    Height( Position P )
    {
        if ( P == NULL )
            return -1;
        else
            return Max( Height( P->Left ), Height( P->Right ) ) + 1;
    }
    
    Position
    SingleRotateWithLeft( Position K1 )
    {
        Position K2 = K1->Left;
        
        K1->Left = K2->Right;
        K2->Right = K1;
        
        /*update height*/
        K1->Height = Height( K1 );
        K2->Height = Height( K2 );
        
        return K2;
    }
    
    Position
    SingleRotateWithRight( Position K1 )
    {
        Position K2 = K1->Right;
        
        K1->Right = K2->Left;
        K2->Left = K1;
        
        /*update height*/
        K1->Height = Height( K1 );
        K2->Height = Height( K2 );
        
        return K2;
    }
    
    Position
    DoubleRotateWithLeft( Position K1 )
    {
        Position K2 = K1->Left;
        Position K3 = K2->Right;
        
        K1->Left = SingleRotateWithRight( K2 );
        return SingleRotateWithLeft( K1 );
    }
    
    Position
    DoubleRotateWithRight( Position K1 )
    {
        Position K2 = K1->Right;
        Position K3 = K2->Left;
        
        K1->Right = SingleRotateWithLeft( K2 );
        return SingleRotateWithRight( K1 );
    }
    
    
    /*AVLTree
    Insert( ElementType X, AVLTree T )
    {
        if ( T == NULL )
        {
            T = ( AVLTree )malloc( sizeof( struct AVLNode ) );
            if ( T == NULL )
            {
                printf( "No Space!!!\n" );
                exit( 1 );
            }
            T->Element = X;
            T->Left = NULL;
            T->Right = NULL;
        }
        else if ( X < T->Element )
            T->Left = Insert( X, T->Left );
        else if ( X > T->Element )
            T->Right = Insert( X, T->Right );
        
        return T;
    }*/