[数据结构与算法] : AVL树

头文件

typedef int ElementType;

#ifndef _AVLTREE_H_
#define _AVLTREE_H_

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);
void PrintTree(AvlTree T);

#endif

 

源文件

#include "fatal.h"
#include "avltree.h"
#include <malloc.h>

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

AvlTree MakeEmpty(AvlTree T) // 同二叉查找树
{
    if(T != NULL) // 递归终止
    {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        free(T);
    }
    return T;
}

Position Find(ElementType X, AvlTree T) // 同二叉查找树
{
    if(T == NULL)
        return NULL;
    else if(X < T->Element)
    {
        return Find(X, T->Left);
    }
    else if(X > T->Element)
    {
        return Find(X, T->Right);
    }
    else
        return T;
}

Position FindMin(AvlTree T) // 递归实现
{
    if(T == NULL)
        return NULL;
    else if(T->Left == NULL)
        return T;
    else
        return FindMin(T->Left);
}

Position FindMax(AvlTree T) // 非递归实现
{
    if(T != NULL)
        while(T->Right != NULL)
            T = T->Right;

    return T;
}

static int Height(Position P)
{
    if(P == NULL)
        return -1; // 空树高度为-1
    else
        return P->Height;
}

static int Max(int Left, int Right)
{
    return Left > Right ? Left : Right;
}

/* This function can be called only if K2 has a left child */
/* Perform a rotate between a node (K2) and its left child */
/* Update heights, then return new root */
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->Right)) + 1;

    return K1;  /* New root */
}

/* This function can be called only if K1 has a right child */
/* Perform a rotate between a node (K1) and its right child */
/* Update heights, then return new root */
static Position SingleRotateWithRight(Position K1)
{
    Position K2;

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

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

    return K2;  /* New root */
}

/* This function can be called only if K3 has a left */
/* child and K3's left child has a right child */
/* Do the left-right double rotation */
/* Update heights, then return new root */
static Position DoubleRotateWithLeft(Position K3)
{
    /* Rotate between K1 and K2 */
    K3->Left = SingleRotateWithRight(K3->Left);
    /* Rotate between K3 and K2 */
    return SingleRotateWithLeft(K3);
}

/* This function can be called only if K1 has a right */
/* child and K1's right child has a left child */
/* Do the right-left double rotation */
/* Update heights, then return new root */
static Position DoubleRotateWithRight(Position K1)
{
    /* Rotate between K3 and K2 */
    K1->Right = SingleRotateWithLeft(K1->Right);
    /* Rotate between K1 and K2 */
    return SingleRotateWithRight(K1);
}

// 1. 找位置; 2. 插入; 3. 平衡性; 4. 旋转
AvlTree Insert(ElementType X, AvlTree T)
{
    if(T == NULL)
    {
        /* Create and return a one-node tree */
        T = (AvlTree)malloc(sizeof(struct AvlNode));
        if(T == NULL)
            FatalError("Out of space!");
        else
        {
            T->Left = T->Right = NULL;
            T->Height = 0;
            T->Element = X;
        }
    }
    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);
        }
    }
    /* Else X is in the tree already; we'll do nothing */
    T->Height = Max(Height(T->Left), Height(T->Right)) + 1;

    return T;
}

AvlTree Delete(ElementType X, AvlTree T)
{
    printf( "Sorry; Delete is unimplemented; %d remains\n", X );
    return T;
}

ElementType Retrieve(Position P)
{
    return P->Element;
}

void PrintTree(AvlTree T)
{
    if( T != NULL)
    {
        PrintTree(T->Left);
        printf("%d ", T->Element);
        PrintTree(T->Right);
    }
}

 

测试文件

#include "avltree.h"
#include <stdio.h>

main( )
{
    AvlTree T;
    Position P;
    int i;
    int j = 0;

    T = MakeEmpty( NULL );
    for( i = 0; i < 50; i++, j = ( j + 7 ) % 50 )
        T = Insert( j, T );
    for( i = 0; i < 50; i++ )
        if( ( P = Find( i, T ) ) == NULL || Retrieve( P ) != i )
            printf( "Error at %d\n", i );

 /* for( i = 0; i < 50; i += 2 )
        T = Delete( i, T );

    for( i = 1; i < 50; i += 2 )
        if( ( P = Find( i, T ) ) == NULL || Retrieve( P ) != i )
            printf( "Error at %d\n", i );
    for( i = 0; i < 50; i += 2 )
        if( ( P = Find( i, T ) ) != NULL )
            printf( "Error at %d\n", i );
*/
    printf( "Min is %d, Max is %d\n", Retrieve( FindMin( T ) ),
               Retrieve( FindMax( T ) ) );
    PrintTree(T);
    return 0;
}