C语言树形输出AVL树28个随机数的插入过程

C语言打印，树按水平方向生长，○代表一个空结点。

---------------------------------------

1

---------------------------------------

┌──56

1

└○

---------------------------------------

┌──56

20

└──1

---------------------------------------

┌──81

┌──56

│ └○

20

└──1

---------------------------------------

┌──81

┌──58

│ └──56

20

└──1

---------------------------------------

┌──81

┌──58

│ └○

56

│ ┌──48

└──20

└──1

---------------------------------------

┌──81

┌──58

│ └○

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

└──1

---------------------------------------

┌──89

┌──81

│ └──58

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

└──1

---------------------------------------

┌○

┌──89

│ └──82

┌──81

│ └──58

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

└──1

---------------------------------------

┌○

┌──89

│ └──82

┌──81

│ │ ┌──74

│ └──58

│ └○

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

└──1

---------------------------------------

┌○

┌──89

│ └──82

┌──81

│ │ ┌──74

│ └──58

│ └○

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

│ ┌──18

└──1

└○

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──58

│ └○

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

│ ┌──18

└──1

└○

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌○

│ ┌──48

│ │ └──35

└──20

│ ┌──18

└──1

└○

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ └──35

└──20

│ ┌──18

└──1

└○

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌──18

└──1

└○

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌──18

└──2

└──1

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──10

└──2

└──1

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌──37

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──10

└──2

└──1

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌──37

│ │ └──35

│ │ └──31

└──20

│ ┌──18

│ ┌──15

│ │ └──10

└──2

└──1

---------------------------------------

┌──89

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌──37

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──10

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌──37

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──10

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ └──45

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──10

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ └──45

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ └──45

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ └──45

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──51

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ └──58

56

│ ┌──53

│ ┌──51

│ │ └○

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ │ ┌○

│ └──58

│ └──57

56

│ ┌──53

│ ┌──51

│ │ └○

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ └──71

│ │ ┌──60

│ └──58

│ └──57

56

│ ┌──53

│ ┌──51

│ │ └○

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ │ ┌──71

│ │ │ └──61

│ └──60

│ │ ┌○

│ └──58

│ └──57

56

│ ┌──53

│ ┌──51

│ │ └○

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

┌──98

┌──89

│ └○

┌──86

│ └──82

┌──81

│ │ ┌──74

│ │ ┌──71

│ │ │ └──61

│ └──60

│ │ ┌○

│ └──58

│ └──57

56

│ ┌──53

│ ┌──51

│ │ └○

│ ┌──48

│ │ │ ┌○

│ │ └──45

│ │ └──38

│ ┌──37

│ │ │ ┌○

│ │ └──35

│ │ └──31

└──20

│ ┌○

│ ┌──18

│ │ └──17

└──15

│ ┌──12

│ ┌──10

│ │ └○

└──2

└──1

---------------------------------------

代码如下：

/* AvlTree.h */
#ifndef _AVLTREE_H_
#define _AVLTREE_H_

#define elementType int

struct AvlNode;
typedef struct AvlNode *AvlTree;
typedef struct AvlNode *AvlPos;

AvlTree insertAvl(elementType X, AvlTree T);
AvlTree deleteAvl(elementType X, AvlTree T);
void printAvlTree( AvlTree T );
void drawAvlTree( AvlTree T );

#endif

/* AvlTree.c */
#include <stdlib.h>
#include <stdio.h>
#include "AvlTree.h"

#define LEFT 0
#define RIGHT 1

struct AvlNode {
elementType element;
AvlTree left;
AvlTree right;
int height;
};

void error( char *str )
{
printf( str );
printf( "\n" );
exit( EXIT_FAILURE );
}

AvlPos findMax( AvlTree T )
{
if ( T )
while ( T->right )
T = T->right;
return T;
}

AvlPos findMin( AvlTree T )
{
if ( T )
while ( T->left )
T = T->left;
return T;
}

int getHeight( AvlPos P )
{
if ( !P )
return -1;
else
return P->height;
}

AvlPos singleRotate2Right( AvlPos P2 )
{
AvlPos P1;
P1 = P2->left;
P2->left = P1->right;
P1->right = P2;

P2->height = max( getHeight( P2->left ), getHeight( P2->right ) ) + 1;
P1->height = max( getHeight( P1->left ), getHeight( P1->right ) ) + 1;
return P1;
}

AvlPos singleRotate2Left( AvlPos P2 )
{
AvlPos P1;
P1 = P2->right;
P2->right = P1->left;
P1->left = P2;

P2->height = max( getHeight( P2->left ), getHeight( P2->right ) ) + 1;
P1->height = max( getHeight( P1->left ), getHeight( P1->right ) ) + 1;
return P1;
}

AvlPos doubleRotate2Right( AvlPos P )
{
P->left = singleRotate2Left( P->left );
return singleRotate2Right( P );
}

AvlPos doubleRotate2Left( AvlPos P )
{
P->right = singleRotate2Right( P->right );
return singleRotate2Left( P );
}

AvlTree insertAvl( elementType X, AvlTree T )
{
if ( !T ) {
T = malloc( sizeof(struct AvlNode) );
if ( !T )
error( "Memory allocation error!" );
else {
T->element = X;
T->left = NULL;
T->right = NULL;
T->height = 0;
}
}
else if ( X < T->element ) {
T->left = insertAvl( X, T->left );
if ( getHeight( T->left ) - getHeight( T->right ) == 2 ) {
if ( X < T->left->element )
T = singleRotate2Right( T );
else
T = doubleRotate2Right( T );
}
}
else if ( X > T->element ) {
T->right = insertAvl( X, T->right );
if ( getHeight( T->right ) - getHeight( T->left ) == 2 ) {
if ( X > T->right->element )
T = singleRotate2Left( T );
else
T = doubleRotate2Left( T );
}
}

T->height = max( getHeight( T->left ), getHeight( T->right ) ) + 1;
return T;
}

AvlPos rotate( AvlPos P )
{
if ( getHeight( P->left ) - getHeight( P->right ) == 2 ) {
if ( getHeight( P->left->left ) < getHeight( P->left->right ) )
P = doubleRotate2Right( P );
else
P = singleRotate2Right( P );
}
else if ( getHeight( P->right ) - getHeight( P->left ) == 2 ) {
if ( getHeight( P->right->right ) < getHeight( P->right->left ) )
P = doubleRotate2Left( P );
else
P = singleRotate2Left( P );
}
return P;
}

AvlTree deleteAvl( elementType X, AvlTree T )
{
AvlPos tmpPos;

if ( !T ) {
printf( "Element (%d) not found!\n", X );
return T;
}
else if ( X < T->element ) {
T->left = deleteAvl( X, T->left );
T = rotate( T );
}
else if ( X > T->element ) {
T->right = deleteAvl( X, T->right );
T = rotate( T );
}
else if ( T->left && T->right ) {
//both subtrees are not NULL.
if ( T->left->height > T->right->height ) {
//if left subtree is higher.
tmpPos = findMax( T->left );
T->element = tmpPos->element;
T->left = deleteAvl( T->element, T->left );
T = rotate( T );
}
else {
//if right subtree is higher or both are equal.
tmpPos = findMin( T->right );
T->element = tmpPos->element;
T->right = deleteAvl( T->element, T->right );
T = rotate( T );
}
}
else {
//one of the two subtrees is NULL.
tmpPos = T;
if ( !T->left )
T = T->right;
else
T = T->left;
free( tmpPos );
return T;
}

T->height = max( getHeight( T->left ), getHeight( T->right ) ) + 1;
return T;
}

void printAvl( AvlTree T, int *count )
{
if ( T ) {
printAvl( T->left, count );
printf( "%d  ", T->element );
++ *count;
printAvl( T->right, count );
}
}

void printAvlTree( AvlTree T )
{
int count = 0;
printf( "(" );
printAvl( T, &count );
printf( "):%d nodes\n", count );
}

void drawAvl( AvlTree T, int depth, int *LR )
{
int i;

//print right subtree.
LR[depth] = RIGHT;
if ( T->right ) {
drawAvl( T->right, depth + 1, LR );
}
else if ( T->left ) {
//if right subtree is NULL and left subtree is not NULL, draw right subtree as a NULL node.
for ( i = 1; i <= depth; i++ )
if ( LR[i-1] - LR[i] )
printf( "│    " );
else
printf( "      " );
if ( i == depth + 1 )
printf( "┌○\n" );
}

//print current node.
for ( i = 1; i < depth; i++ )
if ( LR[i-1] - LR[i] )
printf( "│    " );
else
printf( "      " );
if ( i == depth )
if ( LR[i-1] == RIGHT )
printf( "┌──" );
else if ( LR[i-1] == LEFT )
printf( "└──" );
printf( "%d\n", T->element );

//print left subtree.
LR[depth] = LEFT;
if ( T->left ) {
drawAvl( T->left, depth + 1, LR );
}
else if ( T->right ) {
//if left subtree is NULL and right subtree is not NULL, draw left subtree as a NULL node.
for ( i = 1; i <= depth; i++ )
if ( LR[i-1] - LR[i] )
printf( "│    " );
else
printf( "      " );
if ( i == depth + 1 )
printf( "└○\n" );
}
}

void drawAvlTree( AvlTree T )
{
int *LR;

if ( !T )
error( "Tree is NULL!" );

LR = calloc( getHeight( T ) + 1, sizeof( int ) );
if ( LR ) {
drawAvl( T, 0, LR );
free( LR );
printf( "---------------------------------------\n" );
}
else
error( "Memory allocation error!" );
}

/* mian.c */
#include <stdlib.h>
#include "AvlTree.h"

main()
{
int i;
AvlTree tree = NULL;
/*
tree = insertAvl( 3, NULL );
drawAvlTree( tree );

tree = insertAvl( 2, tree );
drawAvlTree( tree );

tree = insertAvl( 1, tree );
drawAvlTree( tree );

tree = insertAvl( 4, tree );
drawAvlTree( tree );

tree = insertAvl( 5, tree );
drawAvlTree( tree );

tree = insertAvl( 6, tree );
drawAvlTree( tree );

tree = insertAvl( 7, tree );
drawAvlTree( tree );

tree = insertAvl( 12, tree );
drawAvlTree( tree );

tree = insertAvl( 11, tree );
drawAvlTree( tree );

tree = insertAvl( 10, tree );
drawAvlTree( tree );

tree = insertAvl( 8, tree );
drawAvlTree( tree );

tree = insertAvl( 9, tree );
drawAvlTree( tree );

tree = deleteAvl( 12, tree );
drawAvlTree( tree );

tree = deleteAvl( 8, tree );
drawAvlTree( tree );

tree = deleteAvl( 4, tree );
drawAvlTree( tree );

tree = deleteAvl( 6, tree );
drawAvlTree( tree );

tree = deleteAvl( 5, tree );
drawAvlTree( tree );

tree = deleteAvl( 7, tree );
drawAvlTree( tree );

tree = deleteAvl( 9, tree );
drawAvlTree( tree );

tree = deleteAvl( 10, tree );
drawAvlTree( tree );

tree = deleteAvl( 11, tree );
drawAvlTree( tree );

tree = deleteAvl( 3, tree );
drawAvlTree( tree );

tree = deleteAvl( 2, tree );
drawAvlTree( tree );

tree = deleteAvl( 1, tree );
drawAvlTree( tree );
*/
for ( i = 1; i < 32; i++ ) {
tree = insertAvl( rand()*99/RAND_MAX + 1, tree );
drawAvlTree( tree );
}
printAvlTree( tree );
}