Quando eu crescer quero ser assim...

Rock on ! Baby...

"Quando falo contigo, no meu peito
Esquece-me esta dor que me consome:
Talvez corre o prazer nas fibras d'alma:
E eu ouso ainda murmurar teu nome!"

Álvarez de Azevedo

“O espírito de um novo horizonte cai em sonhos antigos”

clique na imagem para ampliar

Vou ter que aprender a viver sem você

Porque não da para sentar ao seu lado

Sabendo que nunca vou te ter

Terei que esquecer sua voz

Pois não dá para de seus lábios lembrar

Sem ser tomado pela vontade de te beijar

Vou esquecer que quis te abraçar

Pois eu não poderia viver

Sem uma palavra apaixonada te falar

Devo esquecer que te desejei

Porque não quero seguir em frente

Pensando por que nunca com você fiquei

Chega a ser irônica a dificuldade de te esquecer

Quando na verdade foi tão fácil

Aprender a gostar de você

Peruvian Skies

// INSERÇÃO EM ÁRVORE BINÁRIA DE BUSCA:

void inserir(tArvore **a, int elem)
{
 if (*a == NULL)
 {
   *a = (tArvore *) malloc(sizeof(tArvore));
   (*a)->centro = elem;
   (*a)->hEsquerda =  NULL;
   (*a)->hDireita = NULL;
 }
 else if ((*a)->centro < elem)
   inserir(&(*a)->hDireita, elem);
 else if ((*a)->centro > elem)
   inserir(&(*a)->hEsquerda, elem);
}

// BUSCA BINÁRIA EM UMA ABB:

int buscar(tArvore *a, int elem)
{
 if (a == NULL)
   return 0;
 else if (a->centro < elem)
   return buscar(a->hDireita, elem);
 else if (a->centro > elem)
   return buscar(a->hEsquerda, elem);
 else
   return 1;
}

...o trab do diabo viu

ps.: Não faço nem idéia c esse cod tah direito !

Essa árvore deve funcionar...

typedef struct tree_node tree_node, *tree;

struct tree_node {
     tipo data;
     tree left;
     tree right;
   }

typedef enum { PREORDER,INORDER,POSTORDER } ORDER;

# define DATA(T) ((T)->data)
# define LEFT(T) ((T)->left)
# define RIGHT(T) ((T)->right)

int allocate_tree_node (tree *p_T, tipo data) {
 tree T;

 T = (tree)malloc (sizeof(tree_node));
 if (T==NULL)
   return ERRO;
 *p_T = T;
 DATA(T) = data;
 LEFT(T) = NULL:
 RIGHT(T) = NULL;
 return OK;
}

void free_tree_node(tree *p_T) {
 free(*p_T);
 *p_T=NULL:
}

int init_tree (tree *p_T) {
 *p_T=NULL;
 return OK;
}

int empty_tree(tree T) {
 return (T==NULL) ? TRUE : FALSE;
}

int make_root(tree *p_T, tipo data, tree right, tree left)
 if (empty_tree(*p_T) == FALSE)
   return ERRO;
 if (allocate_tree_node(p_T,data) == ERRO)
   return ERRO;
 LEFT(*p_T) = left;
 RIGHT(*p_T) = right;
 return OK;
}

void destroy_tree(tree *p_T, void (*p_func_f)() ) {
 if (empty_tree(*p_T) == FALSE) {
   destroy_tree(&LEFT(*p_T),p_func_f);
   if (p_func_f != NULL)
     (*p_func_f)(DATA(*p_T);
   free_tree_node(p_T);
 }
}

int traverse_tree(tree T,int (*p_func_f)(), ORDER order) {
 switch (order) {
   case PREORDER : return preorder_traverse(T,p_func_f);
   case INORDER : return inorder_traverse(T,p_func_f);
   case POSTORDER : return postorder_traverse(T,p_func_f);
 }
 return ERROR;
}

int preorder_traverse (tree T,int (*p_func_f)() ) {
 int rc;

 if (empty_tree(T) == TRUE)
   return OK;
 rc = (*p_func_f)(DATA(T));
 if (rc==OK)
   rc = preorder_traverse(LEFT(T),p_func_f);
 if (rc==OK)
   rc = preorder_traverse(RIGHT(T),p_func_f);
 return rc;
}

int inorder_traverse (tree T,int (*p_func_f)() ) {
 int rc;

 if (empty_tree(T) == TRUE)
   return OK;
 rc = inorder_traverse(LEFT(T),p_func_f);
 if (rc==OK)
   rc = (*p_func_f)(DATA(T),p_func_f);
 if (rc==OK)
   rc = inorder_traverse(RIGHT(T),p_func_f);
 return rc;
}

int postorder_traverse (tree T,int (*p_func_f)() ) {
 int rc;

 if (empty_tree(T) == TRUE)
   return OK;
 rc = postorder_traverse(LEFT(T),p_func_f);
 if (rc==OK)
   rc = inorder_traverse(RIGHT(T),p_func_f);
 if (rc==OK)
   rc = (*p_func_f)(DATA(T),p_func_f);
 return rc;
}

Só para descontrair...