数据结构与算法分析之--->AvlTree的实现

主体风格参照Weiss于《数据结构与算法分析（C语言描述）》中的AvlTree的相关描述

自己补全了AvlTree的删除等操作以及课后习题的高效率双旋转

/* Project: AvlTree						*/
/* Author: ZZ_InoRi/Elasped_Hiyoti				*/
/* Home: http://blog.csdn.net/Elapsed_Hiyori		        */
/* IDE: VS2012							*/
/* Date: 2012/11/27	-> 19:53				*/
/* ============================================================ */

#define _AvlTree_H

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

#ifdef  _AvlTree_H

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

AvlTree		MakeEmpty( AvlTree T );
Position	FindMax( AvlTree T );
Position	FindMin( AvlTree T );
Position	Find( AvlTree T );
AvlTree		Insert( int X, AvlTree T );
AvlTree		Delete( int X, AvlTree T );
int			Retrueve( Position P );

#endif  /* _AvlTree_H */


struct AvlNode{

	int		Element;
	AvlTree	Left;
	AvlTree	Right;
	int		Height;

};


int Retrieve( Position P ){

    return P -> Element;
}


void PrintElement( int X ){

	printf("%d\t",X);
}


void PrintTree( AvlTree T ){

	if( T != NULL ){

		PrintTree( T -> Left );
		PrintElement( T -> Element );
		PrintTree( T -> Right );
	}
}


static int Height( Position P ){

	if( P == NULL )
		return -1;
	else
		return P -> Height;

}

static int Max( int a, int b ){

	return a > b ? a : b;

}

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 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

}


static Position SingleRotateWithRight( Position K1 ){

	Position K2;

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

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

	return K2; // New Root

}


static Position DoubleRotateWithLeft( Position K3 ){

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

	return SingleRotateWithLeft( K3 );

}


static Position DoubleRotateWithRight( Position K3 ){

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

	return SingleRotateWithRight( K3 );

}

	

AvlTree Insert( int X, AvlTree T ){

	if( T == NULL ){

		T = ( AvlTree )malloc( sizeof( struct AvlNode ) );
		if( T == NULL )
			return 0;
		else{

			T -> Element = X;
			T -> Height = 0;
			T -> Left = T -> Right = NULL;
		}
	}

	else if( X < T -> Element ){

		T -> Right = Insert( X, T -> Right );
		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; 

}


/*  以下为高效率的双旋转  */


Position H_DoubleRotateWithLeft( Position K3 )
{
	Position K1, K2;
	K1 = K3->Left;
	K2 = K1->Right;
	K1->Right = K2->Left;
	K3->Left = K2->Right;
	K2->Left = K1;
	K2->Right = K3;
	K1->Height = Max( Height(K1->Left), Height(K1->Right) ) + 1;
	K3->Height = Max( Height(K3->Left), Height(K3->Right) ) + 1;
	K2->Height = Max( K1->Height, K3->Height ) + 1;
	return K3;
}

/*  其实该效率略高的双旋转即手动双旋转，虽然效率略高，但是不直观  */



/*  假设要删除的结点是T：																				*/
/*  1. 如果T为叶结点，直接删除，然后一直向上调整到根结点；												*/
/*  2. 如果T有左子树L，找到L的最右结点X（就是<T的结点中最大的），用X的值替换掉T的值，问题变为删除X结点；  */
/*  3. 如果T有右子树R，找到R的最右结点X（就是>T的结点中最小的），用X的值替换掉T的值，问题变为删除X结点；  */


AvlTree Delete( int X, AvlTree T){

	Position TempCell;

	if( T == NULL ){

		printf("Element Not Found\n");
		return NULL;
	}

	else if( X > T -> Element ){

		T -> Right = Delete( X, T -> Right );
		if( Height( T -> Left ) - Height( T -> Right ) == 2 ){

			if( Height( T -> Left -> Left ) > Height( T -> Left -> Right ) ){
				// LL
				SingleRotateWithLeft( T );
			}
			else {
				// LR
				DoubleRotateWithLeft( T );
			}
		}
	}

	else if( X < T -> Element ){

		T -> Left = Delete( X, T -> Left );
		if( Height( T -> Right ) - Height( T -> Left ) == 2 ){

			if( Height( T -> Right -> Right ) > Height( T -> Right -> Left ) ){
				// RR
				SingleRotateWithRight( T );
			}
			else {
				// RL
				DoubleRotateWithRight( T );
			}
		}
	}

	else if( X == T -> Element ){
		// Find it
		if( T -> Right && T -> Left ){
			// Two Children
			TempCell = FindMin( T -> Right );
			T -> Element = TempCell -> Element;
			TempCell -> Element = X;
			Delete( X, T -> Right );

		}
		else {
			// One or Zero Child
			TempCell = T;
			if( T -> Right || T -> Left ){
				
				if( T -> Right == NULL )
					T = T -> Left;
				if( T -> Left == NULL )
					T = T -> Right;

				free( TempCell );
			}

			else {

				free( T );
				T = NULL;
			}
		}
	}

	return T;
}