ESTRUCTURA ARBOLES

MAIN:

#include <stdio.h>
#include <stdlib.h>
#include "header.h"
int main()
{
    int opcion, orden_opc, aux;
    P_NODO_ARBOL a = NULL;

    do
    {
        printf("\n\n1.Insertar\n");
        printf("2.Encontrar\n");
        printf("3.Salir\n");
        printf("\nIntroduce una opcion: ");
        scanf("%d",&opcion);

        switch (opcion)
        {
        case 1:
            printf("\nTelefono a insertar: ");
            scanf("%d",&aux);
            a = insertar(a, aux);
            printf("\nTelefono insertado");
           /* printf("\nNombre a insertar: ");
            scanf("%d",&aux2);
            a = insertar(a, aux2);
            printf("\nNombre insertado");
            */break;

        case 2:
            printf("\nNumero a encontrar: ");
            scanf("%d",&aux);
            if(encontrar(a, aux) != NULL)
            {
                printf("\nNumero de telefono: %d", encontrar(a, aux)->valor);
                //printf("\nNombre insertado: %d", encontrar(a, aux2)->nombre);
            }
            else
            {
                printf("\nNo encontrado");
            }
            break;


        }

    }
    while (opcion != 7);

    system("pause");
    return 0;
}



HEADER.H:

#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED

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

typedef struct nodo_arbol
{
    int valor;                       /* Campo donde almacenaremos el valor */
    char nombre[255];
    struct nodo_arbol *izq;    /* Puntero al hijo izquierdo */
    struct nodo_arbol *der;      /* Puntero al hijo derecho */
}NODO_ARBOL, *P_NODO_ARBOL;


P_NODO_ARBOL crearArbol();
int esVacio(P_NODO_ARBOL a);
P_NODO_ARBOL insertar(P_NODO_ARBOL arbol, int i);
P_NODO_ARBOL encontrar (P_NODO_ARBOL arbol, int i);
void preOrder(P_NODO_ARBOL a);
void postOrder(P_NODO_ARBOL a);
void inOrder(P_NODO_ARBOL a);


#endif // HEADER_H_INCLUDED



FUNCIONES.C:

#include "header.h"
/** Crea un arbol vacio*/
P_NODO_ARBOL crearArbol()
{
	return NULL;
}
/** Devuelve 1 si el arbol esta vacio*/
int esVacio(P_NODO_ARBOL a)
{
	return (a==NULL);
}

P_NODO_ARBOL alojar_nodo_arbol()
{
    return((P_NODO_ARBOL)malloc(sizeof(NODO_ARBOL))); /* Reservamos memoria */
}


P_NODO_ARBOL encontrar (P_NODO_ARBOL arbol, int i)
/* Devuelve un apuntador al nodo del arbol "arbol" cuyo contenido es "i", o
 NULL en caso de que no se encuentre este valor */
{
    if (arbol == NULL)    /* Arbol vacÌo por tanto devuelve NULL */
        return (NULL);

    if (arbol->valor == i)    /* Hemos encontrado el valor */
        return (arbol);
    else if (arbol->valor > i)    /* El valor actual es mayor que ir por tanto
                                   vamos hacia la izquierda */
        return(encontrar(arbol->izq, i));
    else    /* "i" es mayor que el valor actual */
        return(encontrar(arbol->der, i));
}



P_NODO_ARBOL insertar(P_NODO_ARBOL arbol, int i)
/* Inserta el valor "i" en el ·rbol apuntado por "arbol" y devuelve un puntero
 a la raÌz del ·rbol resultado. Esta versiÛn no permite duplicados en el
 arbol */
{
    int x;
    P_NODO_ARBOL p;    /* Para no perder la cabeza del arbol */
    //P_NODO_ARBOL h;    /* Para no perder la cabeza del arbol */

    if (arbol == NULL)
    {
        p = alojar_nodo_arbol();             /* Reservamos memoria */
        p->izq = p->der = NULL;             /* Acabamos de crearlo */
        p->valor = i;
        //h = alojar_nodo_arbol();
        //h->izq = h->der = NULL;
        //h->nombre = i;
        return (p);
    }

    if (arbol->valor == i)    /* El valor ya existe. No hacemos nada porque no
                               permitimos valores duplicados */
        return (arbol);

    if (arbol->valor > i) /* "i" es menor que el valor que analizo, por tanto,
                           inserto a la izquierda */
        arbol->izq = insertar(arbol->izq, i);
       // arbol->izq = insertar(arbol->izq, x);

    else  /* "i" es mayor que el valor actual, entonces, inserto a la derecha */
        arbol->der = insertar(arbol->der, i);
        //arbol->der = insertar(arbol->der, x);

    return (arbol);
}


P_NODO_ARBOL borraNodo(P_NODO_ARBOL nodo)
{
	free(nodo);

    return NULL;
}


void preOrder(P_NODO_ARBOL a)//Posterior
{
	if (!esVacio(a))
	{
		preOrder(a->izq);
		preOrder(a->der);


        printf("(%i)-->", a->valor);
    }

}

void postOrder(P_NODO_ARBOL a)//Previo
{
	if (!esVacio(a))
	{

        printf("(%i)-->", a->valor);
		postOrder(a->izq);
		postOrder(a->der);
	}

}

void inOrder(P_NODO_ARBOL a)//Simetrico
{
	if (!esVacio(a))
	{
  		inOrder(a->izq);
  		printf("(%i)-->", a->valor);
  		inOrder(a->der);
	}
}