ARBOL_ALTURA.c

// CREA UN ARBOL Y REALIZA SUS 3 RECORRIDOS Y CALCULA LA ALTURA
#include <stdio.h>
#include <stdlib.h>

struct Nodo
{
	int Dato;
	struct Nodo *Raiz;
	struct Nodo *Izq;
	struct Nodo *Der;
};
struct Nodo *Raiz = NULL;
struct Nodo *Crea_Nodo(int Dato)
{
	struct Nodo *Nuevo = (struct Nodo *)malloc(sizeof(struct Nodo));
	Nuevo->Raiz = Nuevo->Der = Nuevo->Izq = NULL;
	Nuevo->Dato = Dato;
	return Nuevo;
}
// BLOQUE DE ROTACIONES
//===========================================================================
/*
CASO 1:										CASO 4:
		Nodo ConHijoIzq(Nodo k2)						Nodo ConHijoDer(Nodo k1)
		{												{
			Nodo k1 = k2->Izq;								Nodo k2 = k1->Der;
			k2->Izq = k1->Der;								k1->Der = k2->Izq;
			k1->Der = k2;									k2->Izq = k1;
			return k1;										return k2;
		}												}

CASO 2:										CASO 3:
		Nodo DobleConHijoIzq(Nodo k3)					Nodo DobleConHijoDer(Nodo k1)
		{												{
			k3->Izq = ConHijoDer(k3->Izq);						k1->Der = ConHijoIzq(k1->Der);
			return ConHijoIzq(k3);							return ConHijoDer(k1);
		}												}
*/
//===========================================================================


// BLOQUE DE RECORRIDOS
//===========================================================================
void Recorre_PREORDEN(struct Nodo *ARBOL)
{	printf("%d  ", ARBOL->Dato);
	if (ARBOL->Izq != NULL) Recorre_PREORDEN(ARBOL->Izq);
	if (ARBOL->Der != NULL) Recorre_PREORDEN(ARBOL->Der);
}
void Recorre_POSORDEN(struct Nodo *ARBOL)
{	if (ARBOL->Izq != NULL) Recorre_POSORDEN(ARBOL->Izq);
	if (ARBOL->Der != NULL) Recorre_POSORDEN(ARBOL->Der);
	printf("%d  ", ARBOL->Dato);
}
void Recorre_ENTREORDEN(struct Nodo *ARBOL)
{	if (ARBOL->Izq != NULL) Recorre_ENTREORDEN(ARBOL->Izq);
	printf("%d  ", ARBOL->Dato);
	if (ARBOL->Der != NULL) Recorre_ENTREORDEN(ARBOL->Der);
}
void Almacena(struct Nodo *ARBOL, struct Nodo *Nuevo)
{	if (Raiz == NULL) { Raiz = Nuevo; return; }
	if (Nuevo->Dato > ARBOL->Dato)
	{
		if (ARBOL->Der == NULL) {	ARBOL->Der = Nuevo; Nuevo->Raiz = ARBOL; return; }
		else Almacena(ARBOL->Der, Nuevo);
	}
	else				// ARBOL IZQUIERDO
	{
		if (ARBOL->Izq == NULL) { ARBOL->Izq = Nuevo; Nuevo->Raiz = ARBOL; return; }
		else Almacena(ARBOL->Izq, Nuevo);
	}
}
//===========================================================================

struct Nodo *Busca(struct Nodo *ARBOL, int Dato)
{
	if (ARBOL->Dato == Dato) return ARBOL;
	return (Dato > ARBOL->Dato) ? Busca(ARBOL->Der, Dato) : Busca(ARBOL->Izq, Dato);
}

int MAXIMO(int Altura1, int Altura2) { return (Altura1 > Altura2) ? Altura1 : Altura2; }
int Calcula_Altura(struct Nodo *NodoX)
{
	if (NodoX == NULL) return -1;
	return 1 + MAXIMO(Calcula_Altura(NodoX->Izq), Calcula_Altura(NodoX->Der));
}

void Ciclo_De_Operaciones( )
{
	int Opcion = 1, Dato=0;
	struct Nodo *ARBOL = Raiz;

	while ( Opcion )
	{
		printf("1.- Calcular Altura de un nodo\n");
		printf("2.- Muestra en Orden\n");
		printf("0.- Salir\n");
		printf("Seleccione una opcion: "); scanf("%d", &Opcion);
		switch ( Opcion )
		{
			case 0: return;
			case 1: printf("Introduce el nodo al que se le calcularA la altura: "); scanf("%d", &Dato);
					printf("La altura del nodo %d = %d", Dato, Calcula_Altura(Busca(ARBOL, Dato)));
					break;
			case 2:  Recorre_PREORDEN(ARBOL); 
		}
		printf("\n");
	}
}

void Pide_Datos()
{	int k, Datos[7] = {7,2,9,1,5,3,4};			// Cualquier dato
	for (k=0; k<7; k++) Almacena(Raiz, Crea_Nodo(Datos[k]));
}
int main() { Pide_Datos(); Ciclo_De_Operaciones( ); }