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

2023年10月3日 336次阅读来源: AVL树

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 );
}

    原文作者：AVL树
    原文地址: https://blog.csdn.net/jxt_hbtm/article/details/5611611
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。