SoloCodigo

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
}