tengo un problema para definir un tad pila que me guarde arboles(tad arbol),se me ocurre declarar una estructura anidada con los dos tad , o si no que el tad pila me apunte al tad arbol,quiero hacerlo pero no se muy bien la sintaxis en C del leguaje , aqui voy a colocar el tad pila y el tad arbol
/**********tad pila dinamica*********************/ :
#include <stdlib.h>
#include "fatal.h"
typedef int ElementoTipo1;
typedef struct NodoPila *PtrNodo1;
typedef PtrNodo1 Pila;
typedef PtrNodo1 Posicion1;
struct NodoPila
{
ElementoTipo1 Elemento;
Posicion1 Siguiente;
};
void EliminaPila(Pila L)
{
Posicion1 P, Tmp;
P = L->Siguiente;
L->Siguiente = NULL;
while( P != NULL )
{
Tmp = P->Siguiente;
free( P );
P = Tmp;
}
}
Pila CreaPila(Pila L)
{
if(L != NULL)
EliminaPila(L);
L = malloc(sizeof(struct NodoPila));
if(L == NULL)
Error( "Fuera de espacio de memoria" );
L->Siguiente = NULL;
return L;
}
int EstaVacia(Pila L)
{
return L->Siguiente == NULL;
}
int EsUltimo(Posicion1 P)
{
return P->Siguiente == NULL;
}
Posicion1 Encontrar(ElementoTipo1 X, Pila L)
{
Posicion1 P;
P = L->Siguiente;
while( P != NULL && P->Elemento != X )
P = P->Siguiente;
return P;
}
void Pop(Pila L)//va sacando elmentos de la pila dinamicamente
{
Posicion1 NodoTmp;
if(!EsUltimo(L))
{
NodoTmp = L->Siguiente;
L->Siguiente = NodoTmp->Siguiente;
free( NodoTmp );
}
}
void Push(ElementoTipo1 X, Posicion1 L)
{
Posicion1 NodoTmp;
NodoTmp = malloc(sizeof( struct NodoPila));
if(NodoTmp == NULL)
Error("Fuera de espacio de memoria");
NodoTmp->Elemento = X;//el elemento queda guardado al nodo temporal
NodoTmp->Siguiente = L->Siguiente;//el nodo temporal apunrta al tope L->S
L->Siguiente = NodoTmp;//corre el tope al nodo temporal que es el NodoTmp
}
ElementoTipo1 VeaTope(Posicion1 L)
{
return L->Siguiente->Elemento;
/**********aca abajo el tad arbol*****************/:
#include <stdlib.h>
#include "fatal.h"
typedef char ElementoTipo;
struct ArbolNodo;
typedef struct ArbolNodo *Posicion;
typedef struct ArbolNodo *ArbolBusqueda;
ArbolBusqueda VacieArbol(ArbolBusqueda T);
Posicion EncuentreElemento(ElementoTipo X, ArbolBusqueda T);
Posicion EncuentreMinimo(ArbolBusqueda T);
Posicion EncuentreMaximo(ArbolBusqueda T);
ArbolBusqueda InserteElemento(ElementoTipo X, ArbolBusqueda T);
ArbolBusqueda ElimineElemento(ElementoTipo X, ArbolBusqueda T);
ElementoTipo RecupereElemento(Posicion P);
struct ArbolNodo
{
ElementoTipo Elemento;
ArbolBusqueda Izquierdo;
ArbolBusqueda Derecho;
};
ArbolBusqueda VacieArbol(ArbolBusqueda T)
{
if( T != NULL )
{
VacieArbol(T->Izquierdo);
VacieArbol(T->Derecho);
free(T);
}
return NULL;
}
Posicion EncuentreElemento(ElementoTipo X, ArbolBusqueda T)
{
if(T == NULL)
return NULL;
if(X < T->Elemento)
return EncuentreElemento(X, T->Izquierdo);
else
if(X > T->Elemento)
return EncuentreElemento(X, T->Derecho);
else
return T;
}
Posicion EncuentreMinimo(ArbolBusqueda T)
{
if(T == NULL)
return NULL;
else
if(T->Izquierdo == NULL)
return T;
else
return EncuentreMinimo(T->Izquierdo);
}
Posicion EncuentreMaximo(ArbolBusqueda T)
{
if(T != NULL)
while(T->Derecho != NULL)
T = T->Derecho;
return T;
}
ArbolBusqueda InserteElemento(ElementoTipo X, ArbolBusqueda T)
{
if(T == NULL)
{
T = malloc(sizeof( struct ArbolNodo));
if(T == NULL)
ErrorFatal("Out of space!!!");
else
{
T->Elemento = X;
T->Izquierdo = T->Derecho = NULL;
}
}
else
if(X < T->Elemento)
T->Izquierdo = InserteElemento(X, T->Izquierdo);
else
if(X > T->Elemento)
T->Derecho = InserteElemento(X, T->Derecho);
return T;
}
ArbolBusqueda ElimineElemento(ElementoTipo X, ArbolBusqueda T)
{
Posicion TmpCell;
if(T == NULL)
Error("Elemento no encontrado");
else
if(X < T->Elemento)
T->Izquierdo = ElimineElemento(X, T->Izquierdo);
else
if(X > T->Elemento)
T->Derecho = ElimineElemento(X, T->Derecho);
else
if(T->Izquierdo && T->Derecho)
{
TmpCell = EncuentreMinimo(T->Derecho);
T->Elemento = TmpCell->Elemento;
T->Derecho = ElimineElemento(T->Elemento, T->Derecho);
}
else
{
TmpCell = T;
if(T->Izquierdo == NULL)
T = T->Derecho;
else
if(T->Derecho == NULL)
T = T->Izquierdo;
free(TmpCell);
}
return T;
}
ElementoTipo RecupereElemento(Posicion P)
{
return P->Elemento;
}
void ArbolInOrden(ArbolBusqueda T)
{
ElementoTipo i;
if(T != NULL)
{
ArbolInOrden(T->Izquierdo);
printf("%i ",T->Elemento);
ArbolInOrden(T->Derecho);
}
}
void ArbolPostOrden(ArbolBusqueda T)
{
if(T != NULL)
{
ArbolPostOrden(T->Izquierdo);
ArbolPostOrden(T->Derecho);
printf("%i ",T->Elemento);
}
}
void ArbolPreOrden(ArbolBusqueda T)
{
if(T != NULL)
{ printf("%i ",T->Elemento);
ArbolPreOrden(T->Derecho);
ArbolPreOrden(T->Izquierdo);
}
}
si alguien tiene la voluntad y la capcidad de ayudarme, por favor que no trde en hacerlo,
de ante mano gracias
}
