c语言树 实现文件,AA树实现文件C语言

/*AATree.c -- AA树实现文件*/

#include "AATree.h"

/*全局变量声明*/

static Node * NullNode = NULL ;

/*局部函数声明*/

static Node * singleRotateWithLeft (Node * const pn) ;

static Node * singleRotateWithRight (Node * const pn) ;

static Node * skew (Node * pn) ;

static Node * split (Node * pn) ;

static void release (AATree aat) ;

/*接口函数定义*/

Node * Initialize_A (void)

{

if (NULL == NullNode)

{

NullNode = (Node *) malloc (sizeof (Node)) ;

if (NULL == NullNode)

return NULL ;

NullNode -> left = NullNode -> right = NullNode ;

NullNode -> level = 0 ;

}

return NullNode ;

}

AATree Insert_A (AATree aat, const Item item)

{

if (aat == NullNode)

{

/*Create and return a one-node tree.*/

aat = (Node *) malloc (sizeof (Node)) ;

if (NULL == aat)

puts ("Out of space.") ;

else

{

aat -> item = item ;

aat -> level = 1 ;

aat -> left = aat -> right = NullNode ;

}

return aat ;

}

else if (item < aat -> item)

aat -> left = Insert_A (aat -> left, item) ;

else if (item > aat -> item)

aat -> right = Insert_A (aat -> right, item) ;

/*Otherwise it's a duplicate; do nothint.*/

aat = skew (aat) ;

aat = split (aat) ;

return aat ;

}

BOOL Find_A (AATree aat, const Item item)

{

Node * scan = aat ;

while (scan != NullNode)

{

if (item < scan -> item)

scan = scan -> left ;

else if (item > scan -> item)

scan = scan -> right ;

else

return TRUE ;

}

return FALSE ;

}

int Count_A (AATree aat)

{

static count = 0 ;

if (aat != NullNode)

{

Count_A (aat -> left) ;

Count_A (aat -> right) ;

count++ ;

return count ;

}

else

return 0 ;

}

AATree Delete_A (AATree aat, const Item item)

{

static Node * deletePtr, * lastPtr ;

if (aat != NullNode)

{

/*Step 1:Search down tree.*/

/*Set lastPtr and deletePtr.*/

lastPtr = aat ;

if (item < aat -> item)

aat -> left = Delete_A (aat -> left, item) ;

else

{

deletePtr = aat ;

aat -> right = Delete_A (aat -> right, item) ;

}

/*Step 2:If at the bottom of the tree and*/

/*item is present, we delete it.*/

if (aat == lastPtr)

{

if (deletePtr != NullNode && item == deletePtr -> item)

{

deletePtr -> item = aat -> item ;

deletePtr = NullNode ;

aat = aat -> right ;

free (lastPtr) ;

}

}

/*Step 3:Otherwise, we are not at the bottom.*/

/*Rebalance.*/

else

{

if (aat -> left -> level < aat -> level - 1 ||

aat -> right -> level < aat -> level - 1)

{

if (aat -> right -> level > --aat -> level)

aat -> right -> level = aat -> level ;

aat = skew (aat) ;

aat -> right = skew (aat -> right) ;

aat -> right -> right = skew (aat -> right -> right) ;

aat = split (aat) ;

aat -> right = split (aat -> right) ;

}

}

}

return aat ;

}

void Release_A (AATree aat)

{

Release_A (aat) ;

free (NullNode) ;

NullNode = NULL ;

}

/*局部函数定义*/

static Node * singleRotateWithLeft (Node * const pn)

{

Node * left ;

left = pn -> left ;

pn -> left = left -> right ;

left -> right = pn ;

return left ;

}

static Node * singleRotateWithRight (Node * const pn)

{

Node * right ;

right = pn -> right ;

pn -> right = right -> left ;

right -> left = pn ;

return right ;

}

static Node * skew (Node * pn)

{

if (pn -> left -> level == pn -> level)

pn = singleRotateWithLeft (pn) ;

return pn ;

}

static Node * split (Node * pn)

{

if (pn -> right -> right -> level == pn -> level)

{

pn = singleRotateWithRight (pn) ;

pn -> level++ ;

}

return pn ;

}

static void release (AATree aat)

{

if (aat != NullNode)

{

release (aat -> left) ;

release (aat -> right) ;

free (aat) ;

}

}