Manipulação de Árvores Binárias em C.

Listagem de filhos por nível, percursos em pré-ordem, em ordem, e em pós-ordem.

Desenho da árvore até o décimo nível, listagem de dados cadastrais.

Obs: Falta a criação dos menus e submenus. Cabe à inteligência de aprendizado de cada um perceber o que faz cada menu!

• Download Arvore
• Enviar nova versão

Esconder código-fonte

/*
   Universidaade Federal da Bahia
   Instituto de Matematica
   Departamento de Ciencia da Computacao
   MATA40 - Algoritmos e Estruturas de Dados I
   Professor Flavio Assis
   Ivan Carmo da Rocha Neto - Mat: 200620260
   Trabalho de Estruturas de Dados
*/

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


# define NUM 10

/*Declaração da Estrutura da ficha cadastral do Funcionario*/

typedef struct Funcionario{
   char nome[20], depto[30];
   int idnum;
   float salario;
   struct Funcionario *noEsq, *noDir, *noPai, *nomeAnt, *nomeProx; /*Ponteiros p/ a estrutura, p/ listas simples e duplas*/
}Func; /*nomeProx, nomeAnt, idnumProx - ponteiro para proximo (anterior) na lista de nomes (numeros)*/

typedef struct Vetor{
   Func *vet[NUM];    /* listaVetor é uma estrutura, para um vetor que contém listas*/
}listaVetor;

/*Funcao para a comparacao de strings, que sera utilizada para a ordenacao alfabetica*/

int comparaStrings(char str1[], char str2[], int qtd){
   int i = 0;
   
   while(i < qtd){
      if((str1[i] == '{FONTE}') && (str2[i] == '{FONTE}'))
         return(0);
      else{
         if (toupper(str1[i]) == toupper(str2[i]))
            i += 1;
         else{
            if(toupper(str1[i]) > toupper(str2[i]))
               return(1);
            if(toupper(str1[i]) < toupper(str2[i]))
               return(-1);
         }
      }
   }
}             /*Funcao retorna -1, se string1 < string2, e retorna 1 se string1 > string2*/

/*Procedimento para Inicializar as Listas*/

void inicializa(Func **Arvore, Func **lDupla){
   int i = 0;
   (*Arvore) = NULL;           /*inicializa arvore e lista dupla*/
   (*lDupla) = NULL;
};



void percorre_tudo(Func *p, int i){
   if (p!= NULL)
      if (i==1) printf("%d ", p-> idnum); //p^.id é o código do funcionário (chave do nó)
   else{
      i=i-1;
      //if(p -> noEsq != NULL)
         percorre_tudo(p -> noEsq, i); //p^.esq é o apontador para o filho da esquerda (menor)
      //if(p -> noDir != NULL)
         percorre_tudo(p -> noDir, i); //p^.dir é o apontador para o filho da direita (maior)
   }
   else
      printf("[]");
}

void desenha(Func *pai){
   int i;
   
   printf("\n");
   for (i = 1; i <= 10; i++) //listará do nível 1 (raiz) até o 10
   {
      percorre_tudo(pai, i);
      printf("\n");
   }
}

void desenhaListaDup(Func **lDupla){
   Func *p;
   
   p = *lDupla;
   printf("\n");
   if(p != NULL){
      while(p){
         printf("%d ", p -> idnum);
         p = p -> nomeProx;
      }
      printf("\n\n");
      p = *lDupla;
      while(p){
         printf("%s ", p -> nome);
         p = p -> nomeProx;
      }
      printf("\n");
   }
}


/* Procedimento para implementacao da Lista Simples */

/*void insereFichaVetor(listaVetor *lVet, Func **ficha, int posicao){
   Func *p;
   int achou = 0;

   p = (*ficha);
   if(lVet -> vet[posicao] == NULL){
      lVet -> vet[posicao] = p;*/        /*se o vetor for nulo, ele recebe p, que contem o primeiro cadastro*/
   /*}else{
      p = lVet -> vet[posicao];
      if (((*ficha) -> idnum) < (p -> idnum)){
         (*ficha) -> idnumProx = p;
         lVet -> vet[posicao] = (*ficha);*/          /*se logo o primeiro encontrado for Num maior...*/
      /*}else{
         while((!achou) && (p -> idnumProx)){
               if(((*ficha) -> idnum) < (p -> idnumProx -> idnum)){
                  (*ficha) -> idnumProx = p -> idnumProx;
                  p -> idnumProx = (*ficha);
                  achou = 1;
               }else{
                  p = p -> idnumProx;*/     /*neste while, ele vai procurando ate achar um com Num > que ele*/
               /*}
         }
         if(!achou){
           (*ficha) -> idnumProx = p -> idnumProx;
           p -> idnumProx = (*ficha);*/       /*se não encontrar Num maior, insere no final*/
         /*}
      }
   }
};*/


/* Procedimento para implementacao da Arvore */

void insereFichaArvore(Func **ficha, Func **Arvore){
   Func *p;
   int achou = 0;

   p = (*ficha);
   if((*Arvore) == NULL){
      //p -> noEsq = NULL;
      //p -> noDir = NULL;
      //p -> noPai = NULL;
      (*Arvore) = p;
   }else{
      p = (*Arvore);
      while(p && !achou){
         if((*ficha) -> idnum < p -> idnum){
            if(p -> noEsq == NULL){
               p -> noEsq = (*ficha);
               //(*ficha) -> noEsq = NULL;
               //(*ficha) -> noDir = NULL;
               (*ficha) -> noPai = p;
               //p = NULL;
               achou = 1;
            }else
               p = p -> noEsq;
         }else{
            if((*ficha) -> idnum > p -> idnum){
               if(p -> noDir == NULL){
                  p -> noDir = (*ficha);
                  (*ficha) -> noEsq = NULL;
                  (*ficha) -> noDir = NULL;
                  (*ficha) -> noPai = p;
                  //p = NULL;
                  achou = 1;
               }else
                  p = p -> noDir;
            }
         }
      }
   }
}

/*Funcao para implementacao da Lista Dupla*/

void insereFichalDupla(Func **ficha, Func **lDupla){
   Func *p;
   int achou = 0;                      /*funcao que utiliza os mesmos principios da que insere no vetor*/

   p = (*ficha);
   if((*lDupla) == NULL){
      p -> nomeAnt = NULL;
      p -> nomeProx = NULL;
      (*lDupla) = p;
   }else{
      p = (*lDupla);
      if(comparaStrings(((*ficha) -> nome), (p -> nome), 20) < 0){   /*funcao criada para comparar strings*/
         (*ficha) -> nomeAnt = p -> nomeAnt;
         (*ficha) -> nomeProx = p;
         p -> nomeAnt = (*ficha);
         (*lDupla) = (*ficha);
      }else{
         while((p -> nomeProx) && (!achou)){
            if(comparaStrings(((*ficha) -> nome), (p -> nomeProx -> nome), 20) < 0){
               (*ficha) -> nomeProx = p -> nomeProx;
               (*ficha) -> nomeAnt = p;
               p -> nomeProx -> nomeAnt = (*ficha);
               p -> nomeProx = (*ficha);
               achou = 1;
            }else
               p = p -> nomeProx;
         }
         if(!achou){
            (*ficha) -> nomeProx = p -> nomeProx;
            (*ficha) -> nomeAnt = p;
            p -> nomeProx = (*ficha);
         }
      }
   }
}

/*Funcao para Inserir Ficha de Funcionario*/

int insere(Func **Arvore, Func **lDupla, int numero){
   Func *ficha;
   int posicaoVetor, i;
   /*char deptoTemp[30];
   char deptoAdm[] = "administrativo{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}";
   char deptoPed[] = "pesquisa-e-desenvolvimento{FONTE}{FONTE}{FONTE}{FONTE}";
   char deptoProd[] = "producao{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}{FONTE}";*/

   while(numero != 0){
      ficha = ((Func *)malloc(sizeof(Func)));
      getchar();
      gets(ficha -> nome);
      scanf("%d", &ficha -> idnum);
      getchar();
      //scanf("%s ", ficha -> depto);
      //scanf("%s ", ficha -> depto);
      gets(ficha -> depto);        /*leitura de um dado temporario para ser transformado na saida desejada*/
      /*if((deptoTemp[0] == 'a') && (deptoTemp[1] == 'd') && (deptoTemp[2] == 'm')){
         for(i = 0; i< 30; i++){
            (ficha -> depto[i]) = deptoAdm[i];
         }
      }else{
         if((deptoTemp[0] == 'p') && (deptoTemp[1] == 'e') && (deptoTemp[2] == 'd')){
            for(i = 0; i< 30; i++){
               (ficha -> depto[i]) = deptoPed[i];
            }
         }else{
            if((deptoTemp[0] == 'p') && (deptoTemp[1] == 'r') && (deptoTemp[2] == 'o') && (deptoTemp[3] = 'd')){
               for(i = 0; i< 30; i++){
                  (ficha -> depto[i]) = deptoProd[i];
               }
            }
         }
      }*/
      //ficha -> depto = deptoTemp;
      scanf("%f", &ficha -> salario);
      posicaoVetor = (ficha -> idnum) % NUM;
      insereFichaArvore(&ficha, &(*Arvore));          /*chamada de funcao para inserir na arvore*/
      insereFichalDupla(&ficha, &(*lDupla));          /*chamada de funcao para inserir na lista dupla*/
      numero -= 1;
   }
};

/*Funcao para Retirar Funcionario da Lista Simples*/

/*void retiraFichaVetor(listaVetor *lVet, int numero, int posicao){
   Func *p, *q;
   int achou = 0;

   p = lVet -> vet[posicao];
   if(p != NULL){
      if (numero == p -> idnum){
         lVet -> vet[posicao] = p -> idnumProx;*/       /*se o primeiro encontrado, for o que se quer remover, */
      //}else{                                          /*avanca-se a lista em uma posicao*/
         /*while((!achou) && (p -> idnumProx)){
            if(numero == (p -> idnumProx -> idnum)){
               q = p -> idnumProx;
               p -> idnumProx = q -> idnumProx;*/       /*manipulacao de ponteiros para remocao.*/
               //achou = 1;                             /*o free so sera dado depois de manipulados os ponteiros */
            //}else{                                    /*da lista dupla*/
               /*p = p -> idnumProx;
            }
         }
      }
   }
};*/

/*Funcao Facilitador para Remocao*/

Func *MenorDireita(Func *p){
   while(p -> noEsq)
      p = p -> noEsq;
   return p;
}

/*Funcao para Retirar Funcionario da Arvore*/ //********************************************

void retiraFichaArvore(int numero, Func **Arvore){
   Func *p, *menDir, *q, *aux;
   int achou = 0, i;
   
   p = (*Arvore);       /* p eh o que se quer remover */
   aux = ((Func *)malloc(sizeof(Func)));
   while(p && !achou){
      if(numero == p -> idnum)
         achou = 1;
      else 
         if(numero < p -> idnum)
            p = p -> noEsq;
         else
            p = p -> noDir;
   }
   if(achou){
      if((p -> noEsq == NULL)|| (p -> noDir == NULL))
         menDir = p;
      else
         menDir = MenorDireita(p -> noDir);
      if(menDir -> noEsq != NULL)
         q = menDir -> noEsq;
      else
         q = menDir -> noDir;
      if(q != NULL)
         q -> noPai = menDir -> noPai;
      if(menDir -> noPai == NULL)
         (*Arvore) = q;
      else
         if(menDir == menDir -> noPai -> noEsq)
            menDir -> noPai -> noEsq = q;
         else
            menDir -> noPai -> noDir = q;
         printf("p -> idnum = %d\n", p -> idnum);
         usleep(1000000);
         printf("menDir -> idnum = %d\n", menDir -> idnum);
         usleep(1000000);
      if(menDir != p){
         //printf("sdofihsdfiushfiusdh\n");
         for(i = 0; i < 20; i++)
            aux -> nome[i] = p -> nome[i];
         aux -> idnum = p -> idnum;
         for(i = 0; i < 30; i++)
            aux -> depto[i] = p -> depto[i];
         aux -> salario = p -> salario;
         for(i = 0; i < 20; i++)
            p -> nome[i] = menDir -> nome[i];
         p -> idnum = menDir -> idnum;
         for(i = 0; i < 30; i++)
            p -> depto[i] = menDir -> depto[i];
         p -> salario = menDir -> salario;
         for(i = 0; i < 20; i++)
            menDir -> nome[i] = aux -> nome[i];
         menDir -> idnum = aux -> idnum;
         for(i = 0; i < 30; i++)
            menDir -> depto[i] = aux -> depto[i];
         menDir -> salario = aux -> salario;
         aux -> nomeProx = menDir -> nomeProx;
         aux -> nomeAnt = menDir -> nomeAnt;
         if(menDir -> nomeProx != NULL)
            menDir -> nomeProx -> nomeAnt = aux;
         if(menDir -> nomeAnt != NULL)
            menDir -> nomeAnt -> nomeProx = aux;
         
         menDir -> nomeProx = p -> nomeProx;
         menDir -> nomeAnt = p -> nomeAnt;
         if(p -> nomeProx != NULL)
            p -> nomeProx -> nomeAnt = menDir;
         if(p -> nomeAnt != NULL)
            p -> nomeAnt -> nomeProx = menDir;
         
         p -> nomeProx = aux -> nomeProx;
         p -> nomeAnt = aux -> nomeAnt;
         if(aux -> nomeProx != NULL)
            aux -> nomeProx -> nomeAnt = p;
         if(aux -> nomeAnt != NULL)
            aux -> nomeAnt -> nomeProx = p;
         //free(menDir);
         /*if(p -> noPai != NULL){       //*******************
            if(p -> noPai -> noEsq == p)
               p -> noPai -> noEsq = menDir;
            else
               if(p -> noPai -> noDir == p)
                  p -> noPai -> noDir = menDir;
         }else
            (*Arvore) = menDir;
            menDir -> noPai = p -> noPai;
            menDir -> noEsq = p -> noEsq;
            menDir -> noDir = p -> noDir;
            if(p -> noEsq != NULL)
               p -> noEsq -> noPai = menDir;
            if(p -> noDir != NULL)
               p -> noDir -> noPai = menDir;*/       //********************
         /*if(p -> noDir != menDir){
            printf("p -> noDir != menDir\n");
            printf("p -> idnum = %d\n", p -> idnum);
            usleep(1000000);
            printf("menDir -> idnum = %d\n", menDir -> idnum);
            usleep(1000000);
            aux -> noPai = menDir -> noPai;//****
            aux -> noEsq = menDir -> noEsq;
            aux -> noDir = menDir -> noDir;//****
            if(p -> noPai != NULL){
               if(p -> noPai -> noEsq == p)
                  p -> noPai -> noEsq = menDir;
               else
                  if(p -> noPai -> noDir == p)
                     p -> noPai -> noDir = menDir;
            }else
               (*Arvore) = menDir;
            menDir -> noPai = p -> noPai;
            menDir -> noEsq = p -> noEsq;
            menDir -> noDir = p -> noDir;
            if(p -> noEsq != NULL)
               p -> noEsq -> noPai = menDir;
            if(p -> noDir != NULL)
               p -> noDir -> noPai = menDir; //****************************
            if(q != NULL)
               q -> noPai = p;
            p -> noEsq = aux -> noEsq;//****
            p -> noDir = aux -> noDir;
            p -> noPai = aux -> noPai;//****
         }else{
            printf("p -> noDir = menDir\n");
            printf("p -> idnum = %d\n", p -> idnum);
            usleep(1000000);
            printf("menDir -> idnum = %d\n", menDir -> idnum);
            usleep(1000000);
            aux -> noPai = menDir;//*****
            aux -> noEsq = menDir -> noEsq;
            aux -> noDir = menDir -> noDir;//*****
            menDir -> noDir = p;
            menDir -> noEsq = p -> noEsq;
            menDir -> noPai = p -> noPai;
            if(p -> noPai != NULL){
               if(p -> noPai -> noEsq == p)
                  p -> noPai -> noEsq = menDir;
               else
                  if(p -> noPai -> noDir == p)
                     p -> noPai -> noDir = menDir;
            }else
               (*Arvore) = menDir;
            if(p -> noEsq != NULL)
               p -> noEsq -> noPai = menDir;
            p -> noEsq = aux -> noEsq;//***
            p -> noDir = aux -> noDir;
            p -> noPai = aux -> noPai;//***
            if(q != NULL)
               q -> noPai = p;
         }*/
      }
      //free(p);
   }
}

/*Funcao para Retirar Funcionario da Lista Dupla*/

void retiraFichalDupla(int numero, Func **lDupla){
   Func *p, *q;
   int achou = 0;

   p = (*lDupla);
   if(p != NULL){
      if (numero == p -> idnum){
         (*lDupla) = (*lDupla) -> nomeProx;                 /*mesmo principio da remocao da lista simples*/
         free(p);
      }else{
         while((!achou) && (p -> nomeProx)){
            if(numero == (p -> nomeProx -> idnum)){
               q = p -> nomeProx;
               p -> nomeProx = q -> nomeProx;
               if(q -> nomeProx != NULL)
                  q -> nomeProx -> nomeAnt = q -> nomeAnt;
               free(q);
               achou = 1;
            }else{
               p = p -> nomeProx;
            }
         }
      }
   }
};

/*Funcao para retirar funcionario da Lista*/

void retira(Func **Arvore, Func **lDupla, int numero){
   int posicaoVetor;

   posicaoVetor = numero % NUM;                             /*chamada de procedimento para manipulacao de */
   retiraFichaArvore(numero, &(*Arvore));                 /*ponteiros na lista simples*/
   retiraFichalDupla(numero, &(*lDupla));                   /*chamada de procedimento para manipulacao de*/
   //retiraFichaArvore(numero, &(*Arvore));                   /*ponteiros na lista dupla e remocao de ficha*/
};

/*Funcao que consulta dados de funcionario por numero identificacao*/

void consulta(Func **lDupla, int numero){
   Func *p;
   int achou = 0;

   p = *lDupla;
   if(p != NULL){
      while((p) && (!achou)){
         if(numero == (p -> idnum)){            /*procura o id, comparando os ids cadastrados com o id*/
            achou = 1;                                      /*do funcionario ate encontrar um numero */
         }else                                              /*igual ao que se quer, se encontrado, lista */
            p = p -> nomeProx;                             /*os dados do funcionario.*/
      }
      if(achou){
         printf("%s\n", p -> nome);
         printf("%d\n", p -> idnum);
         if((p -> depto[0] == 'a') && (p -> depto[1] == 'd') && (p -> depto[2] == 'm'))
            //printf("%s\n", p -> depto);
            printf("administrativo\n");
         else if((p -> depto[0] == 'p') && (p -> depto[1] == 'e') && (p -> depto[2] == 'd'))
               printf("pesquisa-e-desenvolvimento\n");
         else if((p -> depto[0] == 'p') && (p -> depto[1] == 'r') && (p -> depto[2] == 'o') && (p -> depto[3] = 'd'))
            printf("producao\n");
         else
            printf(" \n");
         printf("%.2f\n", p -> salario);
      }
   }
}

/*Procedimento para listar numeros de funcionarios por indice do vetor*/

/*void listagemVetor(listaVetor *lVet, int posicao){
   Func *p;

   if(posicao < NUM){
      p = lVet -> vet[posicao];*/                          /*percorre a lista da posicao do vetor inteira, */
      //if(p != NULL){                                     /*listando os codigos de todos os funcionarios cadas- */
         //while(p){                                       /*trados nessa posicao de vetor*/
            /*printf("%d\n", p -> idnum);
            p = p -> idnumProx;
         }
      }
   }
}*/

/*Procedimento para a Listagem de Funcionarios Crescente ou Decrescente*/

void listagemNome(Func *lDupla, char ordem){
   char letInicio, aux[20],letFim[20];
   Func *p, *q;
   int achou = 0;

   getchar();
   scanf("%c", &letInicio);
   getchar();
   scanf("%s", &letFim);
   if(letInicio <= letFim[0]){               /*se letra inicio maior que letra fim, nem entra em nada*/
      letInicio = toupper(letInicio);
      letFim[0] = toupper(letFim[0]);
      if (lDupla != NULL){
         while((lDupla) && (!achou)){                       /*vai comparando ate encontrar uma letra menor, */
            aux[0] = toupper(lDupla -> nome[0]);            /*o que significa que sera o local onde iniciara*/
            if(aux[0] >= letInicio){                        /*a listagem*/
               achou = 1;
               p = lDupla;
            }else
               lDupla = lDupla -> nomeProx;
         }
         if( p != NULL){
            achou = 0;
            while((!achou) && (lDupla)){                    /*vai comparando ate encontrar uma letra maior*/
               aux[0] = toupper(lDupla -> nome[0]);         /*o que significa que sera o local onde terminara*/
               if(letFim[0] < aux[0]){                      /*a listagem*/
                  achou = 1;
               }else{
                  q = lDupla;
                  lDupla = lDupla -> nomeProx;
               }
            }
            switch(ordem){             /*o local onde se inicia e onde se termina a listagem, eh indicado*/
               case 'c':{              /*pelos ponteiros p e q*/
                  while((p) != (q)){
                     puts(p -> nome);
                     p = p -> nomeProx;         /*se a opcao for crescente, avancara p ate chegar em q*/
                  }                             /*listando os nomes em cada passagem de p*/
                  puts(q -> nome);
               }break;
               case 'd':{                    /*se a opcao for decrescente, recuara q ate chegar em p*/
                  while((q) != (p)){         /*listando os nomes em cada passagem de q*/
                     puts(q -> nome);
                     q = q -> nomeAnt;
                  }
                  puts(p -> nome);
               }break;
            }
         }
      }
   }
}

/*Procedimento para a Listagem de Codigos por nivel da Arvore*/

void listaCodNivel(Func *Arvore, int nivel){
   
   if((nivel == 1) && (Arvore != NULL))
      printf("%d\n", Arvore -> idnum);
   else{
      if(Arvore -> noEsq != NULL)
         listaCodNivel(Arvore -> noEsq, nivel - 1);
      if(Arvore -> noDir != NULL)
         listaCodNivel(Arvore -> noDir, nivel - 1);
   }
}

/*Funcao para o percurso em Pre-Ordem*/

void percursoPreOrdem(Func *Arvore){

   if(Arvore != NULL){
      printf("%d\n", Arvore -> idnum);
      //if(lDupla -> noEsq != NULL)
         percursoPreOrdem(Arvore -> noEsq);
      //if(lDupla -> noDir != NULL)
         percursoPreOrdem(Arvore -> noDir);
   }
}

/*Funcao para percorrer Arvore em Ordem*/

void percursoEmOrdem(Func *Arvore){

   if(Arvore != NULL){
      //if(lDupla -> noEsq != NULL)
         percursoEmOrdem(Arvore -> noEsq);
      printf("%d\n", Arvore -> idnum); //****************** COLOCAR O NUMERO, NOME SOH PRA TESTES
      //if(lDupla -> noDir != NULL)
         percursoEmOrdem(Arvore -> noDir);
   }
}

/*Funcao para percorrer Arvore em Pos-Ordem*/

void percursoPosOrdem(Func *Arvore){

   if(Arvore != NULL){
      //if(lDupla -> noEsq != NULL)
         percursoPosOrdem(Arvore -> noEsq);
      //if(lDupla -> noDir != NULL)
         percursoPosOrdem(Arvore -> noDir);
      printf("%d\n", Arvore -> idnum);
   }
}

/*Funcao para os percursos na Arvore*/

void percurso(Func *lDupla, int ordem){
   switch(ordem){
      case 'p': percursoPreOrdem(lDupla); break;
      case 'e': percursoEmOrdem(lDupla); break;
      case 'o': percursoPosOrdem(lDupla); break;
      default:break;
   }
   /*if(ordem == 'p')
      percursoPreOrdem(lDupla);
   else if(ordem == 'e')
      percursoEmOrdem(lDupla);
   else if(ordem == 'o')
      percursoPosOrdem(lDupla);*/
}

/*Funcao percurso Filhos para excluir a listagem do pai*/

/*void percursoFilhos(Func *lDupla){
   Func *p;
   
   if(lDupla != NULL){
      numero = lDupla -> idnum;
      //if(lDupla -> noEsq != NULL)
      percursoFilhos(lDupla -> noEsq);
      if(lDupla -> idnum != numero);
         printf("%d\n", lDupla -> idnum);
      //if(lDupla -> noDir != NULL)
      percursoFilhos(lDupla -> noDir);
   }
}*/

/*Funcao para a listagem dos codigos dos Filhos de um no*/

void listaFilhos(Func *lDupla, int numero){     //TESTAAAAARRRRRRR ***********************************
   int achou = 0;
   
   if(lDupla != NULL){
      while(lDupla && !achou){
         if(numero == lDupla -> idnum)
            achou = 1;
         else 
            if(numero < lDupla -> idnum)
               lDupla = lDupla -> noEsq;
            else
               lDupla = lDupla -> noDir;
      }
      if(achou){
         percursoEmOrdem(lDupla -> noEsq);
         percursoEmOrdem(lDupla -> noDir);
      }
   }
}

void caminhoArvore(Func *Arvore){
   
   printf("\n");
   printf("%s\n", Arvore -> nome);
   while(Arvore -> noEsq){
      printf("%s\n", Arvore -> noEsq -> nome);
      Arvore = Arvore -> noEsq;
   }
   printf("\n");
   printf("%s\n", Arvore -> nome);
   while(Arvore -> noPai){
      printf("%s\n", Arvore -> noPai -> nome);
      Arvore = Arvore -> noPai;
   }
   printf("\n");
   printf("%s\n", Arvore -> nome);
   while(Arvore -> noDir){
      printf("%s\n", Arvore -> noDir -> nome);
      Arvore = Arvore -> noDir;
   }
   printf("\n");
   printf("%s\n", Arvore -> nome);
   while(Arvore -> noPai){
      printf("%s\n", Arvore -> noPai -> nome);
      Arvore = Arvore -> noPai;
   }
}

/*Funcao Principal*/

int main(){
   char op[1], escolha, ordem;
   Func *lDupla, *Arvore;
   int numero;

   inicializa(&Arvore, &lDupla);           /*chamada de funcao para inicializar listas*/
      for(;;){
         gets(op);
         switch((op[0])){
            case 'i':{
               //printf("Quantos Funcionarios Inserir? ");
               scanf("%d", &numero);
               insere(&Arvore, &lDupla, numero);       /*chamada da funcao inserir*/
            }break;
            case 'r':{
               printf("Numero de identificacao que se quer remover: ");
               scanf("%d", &numero);
               retira(&Arvore, &lDupla, numero);       /*chamada da funcao retirar*/
            }break;
            case 'c':{
               printf("Numero de Identificacao que se quer consultar: ");
               scanf("%d", &numero);
               consulta(&lDupla, numero);              /*chamada da funcao consulta*/
            }break;
            /*case 'l':{
               printf("Posicao do Vetor que se quer listar: ");
               scanf("%d", &numero);*/
               //listagemVetor(&vetor, numero); ***********/*chamada da funcao listagem de posicao do vetor*/
            //}break;
            case 'o':{
               printf("Ordem em que se quer Listar os nomes: ");
               scanf("%c", &ordem);
               listagemNome(lDupla, ordem);           /*chamada da funcao listagem nome crescente e */
            }break;                                   /*decrescente*/
            case 'n':{
               printf("Nivel da arvore que se quer consultar: ");
               scanf("%d", &numero);
               listaCodNivel(Arvore, numero);
            }break;
            case 'p':{
               //printf("Pre-ordem, em ordem, ou pos-ordem? ");
               scanf("%c", &ordem);
               percurso(Arvore, ordem);            /*chamada de funcao para percorrer a Arvore*/
            }break;
            case 'f':{
               printf("Filhos de qual no? ");
               scanf("%d", &numero);
               listaFilhos(lDupla, numero);             /*chamada de funcao para a listagem dos filhos*/
            }break;
            case 'd': desenha(Arvore); break;
            case 'l': desenhaListaDup(&lDupla); break;
            case 'a': caminhoArvore(Arvore); break;
            case 'e':{
               exit(0);
            }break;
            default:{
            }break;
         }
      }
   return (0);
}

Escolha o algoritmo de ordenação

Soma dos dígitos de um número decimal

Calculadora de fração

Cálculo de Determinantes

Pilha com alocação estática