AVL树

#include <stdio.h>
#include <stdlib.h>

#define MaxSize 1000
#define MAX(a,b)    ( (a) > (b) ? (a) : (b) )

//set empty Treenode's height is 0,according to WIKIPEDIA
typedef int ElementType;

struct AVLTreeNode
{
    ElementType Element;
    int Height;
    struct AVLTreeNode *Left;
    struct AVLTreeNode *Right;
};

struct AVLTreeNode *AVLTreeInit()
{
    struct AVLTreeNode *TreeRoot = NULL;

    return TreeRoot;
}

int GetAVLTreeNodeHeight(struct AVLTreeNode *TreeNode)
{
    if(TreeNode==NULL)
        return 0;
    return TreeNode -> Height;
}

struct AVLTreeNode *LeftLeftRotation(struct AVLTreeNode *OriginalHeigher)
{
    struct AVLTreeNode *OHLeft = OriginalHeigher->Left;

    OriginalHeigher -> Left = OHLeft -> Right;
    OHLeft -> Right = OriginalHeigher;

    OriginalHeigher->Height = MAX(GetAVLTreeNodeHeight(OriginalHeigher->Left),GetAVLTreeNodeHeight(OriginalHeigher->Right))+1;
    OHLeft->Height = MAX(GetAVLTreeNodeHeight(OHLeft->Left),GetAVLTreeNodeHeight(OHLeft->Right))+1;

    return OHLeft;
}

struct AVLTreeNode *RightRightRotation(struct AVLTreeNode *OriginalHeigher)
{
    struct AVLTreeNode *OHRight = OriginalHeigher->Right;

    OriginalHeigher -> Right = OHRight -> Left;
    OHRight -> Left = OriginalHeigher;

    OriginalHeigher->Height = MAX(GetAVLTreeNodeHeight(OriginalHeigher->Left),GetAVLTreeNodeHeight(OriginalHeigher->Right))+1;
    OHRight->Height = MAX(GetAVLTreeNodeHeight(OHRight->Left),GetAVLTreeNodeHeight(OHRight->Right))+1;

    return OHRight;
}

struct AVLTreeNode *LeftRightRotation(struct AVLTreeNode *OriginalHeighest)
{
    OriginalHeighest->Left = RightRightRotation(OriginalHeighest->Left);

    return LeftLeftRotation(OriginalHeighest);
}

struct AVLTreeNode *RightLeftRotation(struct AVLTreeNode *OriginalHeighest)
{
    OriginalHeighest->Left = LeftLeftRotation(OriginalHeighest->Right);

    return RightRightRotation(OriginalHeighest);
}

//warning:decline the same value node
struct AVLTreeNode *AVLTreeNodeInsert(ElementType ToBeInsert,struct AVLTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        TreeRoot = malloc(sizeof(struct AVLTreeNode));
        TreeRoot -> Element = ToBeInsert;
        TreeRoot -> Height = 0;
        TreeRoot -> Left = TreeRoot -> Right = NULL;
    }
    else if(ToBeInsert < TreeRoot->Element)
    {
        TreeRoot->Left = AVLTreeNodeInsert(ToBeInsert,TreeRoot->Left);
        if(GetAVLTreeNodeHeight(TreeRoot->Left)-GetAVLTreeNodeHeight(TreeRoot->Right)==2)
        {
            if(ToBeInsert < TreeRoot->Left->Element)
            {
                TreeRoot = LeftLeftRotation(TreeRoot);
            }
            else
            {
                TreeRoot = LeftRightRotation(TreeRoot);
            }
        }
    }
    else if(ToBeInsert > TreeRoot->Element)
    {
        TreeRoot->Right = AVLTreeNodeInsert(ToBeInsert,TreeRoot->Right);
        if(GetAVLTreeNodeHeight(TreeRoot->Right)-GetAVLTreeNodeHeight(TreeRoot->Left)==2)
        {
            if(ToBeInsert > TreeRoot->Right->Element)
            {
                TreeRoot = RightRightRotation(TreeRoot);
            }
            else
            {
                TreeRoot = RightLeftRotation(TreeRoot);
            }
        }
    }
    else //if ToBeInsert == TreeRoot->Element
    {
        printf("ERROR\n");
    }

    TreeRoot->Height = MAX(GetAVLTreeNodeHeight(TreeRoot->Left),GetAVLTreeNodeHeight(TreeRoot->Right))+1;
    return TreeRoot;
}

struct AVLTreeNode *BinarySearchTreeNodeFindMax(struct AVLTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Right==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMax(TreeRoot->Right);
    }
}

struct AVLTreeNode *BinarySearchTreeNodeFindMin(struct AVLTreeNode *TreeRoot)
{
    if(TreeRoot==NULL)
    {
        return NULL;
    }
    else if(TreeRoot->Left==NULL)
    {
        return TreeRoot;
    }
    else
    {
        return BinarySearchTreeNodeFindMin(TreeRoot->Left);
    }
}

//if doesn't find,return NULL
struct AVLTreeNode *AVLTreeNodeDelete(ElementType ToBeDelete,struct AVLTreeNode *TreeRoot)
{
    if(TreeRoot == NULL)
        return NULL;

    struct AVLTreeNode *TmpCell;
    if(ToBeDelete < TreeRoot -> Element)
    {
        TreeRoot->Left = AVLTreeNodeDelete(ToBeDelete,TreeRoot->Left);
        if(GetAVLTreeNodeHeight(TreeRoot->Right)-GetAVLTreeNodeHeight(TreeRoot->Left)==2)
        {
            TmpCell = TreeRoot->Right;
            if(GetAVLTreeNodeHeight(TmpCell->Right)>GetAVLTreeNodeHeight(TmpCell->Left))
            {
                TreeRoot = RightLeftRotation(TreeRoot);
            }
            else
            {
                TreeRoot = RightRightRotation(TreeRoot);
            }
        }
    }
    else if(ToBeDelete > TreeRoot -> Element)
    {
        TreeRoot->Right = AVLTreeNodeDelete(ToBeDelete,TreeRoot->Right);
        if(GetAVLTreeNodeHeight(TreeRoot->Left)-GetAVLTreeNodeHeight(TreeRoot->Right)==2)
        {
            struct AVLTreeNode *TmpCell = TreeRoot->Left;
            if(GetAVLTreeNodeHeight(TmpCell->Left)>GetAVLTreeNodeHeight(TmpCell->Right))
            {
                TreeRoot = LeftRightRotation(TreeRoot);
            }
            else
            {
                TreeRoot = LeftLeftRotation(TreeRoot);
            }
        }
    }
    else //if(ToBeDelete == TreeRoot -> Element)
    {
        if(TreeRoot->Left && TreeRoot->Right)
        {
            if(GetAVLTreeNodeHeight(TreeRoot->Left)>GetAVLTreeNodeHeight(TreeRoot->Right))
            {
                TmpCell = BinarySearchTreeNodeFindMax(TreeRoot -> Left);
                TreeRoot -> Element = TmpCell -> Element;
                TreeRoot -> Left = AVLTreeNodeDelete(TreeRoot->Element,TreeRoot->Left);
            }
            else
            {
                TmpCell = BinarySearchTreeNodeFindMin(TreeRoot -> Right);
                TreeRoot -> Element = TmpCell -> Element;
                TreeRoot -> Right = AVLTreeNodeDelete(TreeRoot->Element,TreeRoot->Right);
            }
        }
        else
        {
            TmpCell = TreeRoot;
            if(TreeRoot->Left==NULL)
            {
                TreeRoot = TreeRoot -> Right;
            }
            else if(TreeRoot->Right==NULL)
            {
                TreeRoot = TreeRoot -> Left;
            }
            free(TmpCell);
        }
    }
    return TreeRoot;
}

int BinarySearchTreePreOrder(struct AVLTreeNode *TreeRoot)
{
    if(TreeRoot!=NULL)
    {
        printf("%d\n",TreeRoot -> Element);
        BinarySearchTreePreOrder(TreeRoot->Left);
        BinarySearchTreePreOrder(TreeRoot->Right);
    }
    return 0;
}

int main()
{
    struct AVLTreeNode *TreeRoot = AVLTreeInit();
    TreeRoot = AVLTreeNodeInsert(1,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(2,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(3,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(4,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(5,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(6,TreeRoot);
    TreeRoot = AVLTreeNodeInsert(7,TreeRoot);
    TreeRoot = AVLTreeNodeDelete(2,TreeRoot);
    printf("%d\n",TreeRoot->Left->Element);
    return 0;
}