平衡二叉树

/*******  avl.h **********/

/***********************************************************/
/* Copyright (C) SA14226214, USTC, 2014-2015               */
/*                                                         */
/*  FILE NAME             :  avl.h                         */
/*  PRINCIPAL AUTHOR      :  GaoZhipeng                    */
/*  SUBSYSTEM NAME        :  AVL_Tree                      */
/*  MODULE NAME           :  AVL_Tree                      */
/*  LANGUAGE              :  C                             */
/*  TARGET ENVIRONMENT    :  ANY                           */
/*  DATE OF FIRST RELEASE :  2015/05/09                    */
/*  DESCRIPTION           :  This is a bst_tree program    */
/***********************************************************/

/*
 *Revision log:
 *
 *Ceated by GaoZhipeng, 2015/05/09
 *     
 */

#ifndef _AVL_TREE_H
#define _AVL_TREE_H

#define ElementType int 

struct AvlNode;
typedef struct AvlNode *Position;
typedef struct AvlNode *AvlTree;


AvlTree MakeEmpty( AvlTree T );
Position Find( ElementType X, AvlTree T );
Position FindMin( AvlTree T );
Position FindMax( AvlTree T );
AvlTree Insert( ElementType X, AvlTree T );
//AvlTree Delete( ElementType X, AvlTree T );
//ElementType Retrieve( Position P );

static Position SingleRotateWithLeft( Position K2 );
static Position SingleRotateWithRight( Position K1 );
static Position DoubleRotateWithLeft( Position K3 );
static Position DoubleRotateWithRight( Position K1 );


#endif

/******** avl.c **********/

/***********************************************************/
/* Copyright (C) SA14226214, USTC, 2014-2015               */
/*                                                         */
/*  FILE NAME             :  avl.c                         */
/*  PRINCIPAL AUTHOR      :  GaoZhipeng                    */
/*  SUBSYSTEM NAME        :  AVL_Tree                      */
/*  MODULE NAME           :  AVL_Tree                      */
/*  LANGUAGE              :  C                             */
/*  TARGET ENVIRONMENT    :  ANY                           */
/*  DATE OF FIRST RELEASE :  2015/05/09                    */
/*  DESCRIPTION           :  This is a bst_tree program    */
/***********************************************************/

/*
 *Revision log:
 *
 *Ceated by GaoZhipeng, 2015/05/09
 *     
 */

#include<stdio.h>
#include<malloc.h>
#include"avl.h"

struct AvlNode
{
    ElementType Element;
    AvlTree Left;
    AvlTree Right;
    int Height;
};

static int 
Height( Position P ) 
{
    if(P == NULL) 
    {
        return -1;
    }
    else return P->Height;
}


AvlTree MakeEmpty( AvlTree T )
{
    if(T != NULL) 
    {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        free(T);
    }
    return NULL;
}


Position 
Find( ElementType X, AvlTree T ) 
{
    if(T == NULL) 
    {
        return NULL;
    }
    if(T->Element < X) 
    {
        Find(X, T->Left);
    }
    else if(T->Element > X)
    {
        Find(X, T->Right);
    }
    else return T;
}


Position 
FindMin( AvlTree T )
{
    if(T == NULL)
    {    
        return NULL;
    }
    else 
    {
        if(T->Left == NULL) 
        {
            return T;
        }
        else 
        {
            FindMin( T->Left );
        }
    }
}

Position 
FindMax( AvlTree T)
{
    if(T == NULL) 
    {
        return NULL;
    }
    else 
    {
        if(T->Right == NULL) 
        {
            return T;
        }
        else 
        {
            FindMax(T->Right);
        }
    }
}


AvlTree 
Insert( ElementType X, AvlTree T ) 
{
    if(T == NULL) 
    {
        T = malloc( sizeof(struct AvlNode) );
        if(T == NULL)
        {
            printf("Out of space!!!");
        }
        else 
        {
            T->Element = X;
            T->Height = 0;
            T->Left = T->Right = NULL;
        }
    }
    else 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;
}

static Position 
SingleRotateWithLeft( Position K2 )
{
    Position K1;
     
    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), Height(K1->Left) ) + 1;
    return K1;
}

static Position 
SingleRotateWithRight( Position K1 ) 
{
    Position K2;

    K2 = K1->Right;
    K1->Left = K2->Right;
    K2->Right = K1;

    K1->Height = Max( Height(K1->Left), Height(K1->Right) ) + 1;
    K2->Height = Max( Height(K2->Left), Height(K2->Right) ) + 1;

    return K2;
}


static Position 
DoubleRotateWithLeft(Position K3)
{
    Position K1; 

    K1 = K3->Left;
    K3->Left = SingleRotateWithRight( K1 );

    return SingleRotateWithLeft(K3);
}

static Position 
DoubleRotateWithRight(Position K1) 
{
    Position K3;

    K3 = K1->Right;
    K1->Right = SingleRotateWithLeft(K3);

    return SingleRotateWithRight(K1);
}

int Max( int H1, int H2 )
{
    return H1>H2 ? : H1, H2;
}