<strong>Lista duplamente encadeada em C</strong>

Bueno, vou postar meu primeiro trabalho de programação que eu fiz em C no segundo nível de Ciência da Computação na UPF, não sei como mas tiramos 10 neste trabalho

/*..::Bibliotecas incluidas::..*/ 

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

 /*..::Definicao da constante::..*/
#define TAMANHO 6

/*..::Prototipagem::..*/
void cria_pnd( void );
void cria_nc( void );
int obtem( void );
void mostra_lista( void );
int inclusao( void );
void consulta( void );
void retirada( void );
void libera( int indice );
void mostra_elo_a ( void );
void mostra_elo_p ( void );
void nodos_disp ( void );
void esvazia_lista ( void );
void total ( void );
void dados_pessoais ( void );
void menu ( char *p );
void processa_menu ( char *a );
void alerta( void );

/*..::declaracao da estrutura..::*/
struct nodo {
       char  descricao[20];
       char  unidade[3];
       float quantidade;
       float vlr_unitario;
       int   elo_a;
       int   elo_p;
};

/*..::Declaracao de variaveis globais::..*/
struct nodo lista[TAMANHO];
int nc;
int disp;
char  aux_descricao[20];
char  aux_unidade[3];
float aux_quantidade;
float aux_vlr_unitario;

/* ....::::INICIO DO PROGRAMA PRINCIPAL::::.... */
int main(void)
{
/*..::Declaracao das variaveis do prog principal::..*/
    char  opcao;

    system("color 1f");
    dados_pessoais();
    cria_pnd();
    cria_nc();

    while ( 1 ){
        menu ( &opcao );
        processa_menu ( &opcao );
    }
fflush(stdin); getchar(); return(0);
}

/*.........::::::::::::::::::FUNÇÕES::::::::::::::::::.........*/
void alerta(void){
     int i=0;
        for(i=1; i<=50; i++){
              if(i%8 == 0)
                  system ("color 9f");
              else
                  system("color 4f");
        }
fflush(stdin);
}

/*Função que mostra os dados do do programador*/
void dados_pessoais ( void ){

    printf("\n\n\n\n");
    printf("\n  _________________________________________________________________________\n");
    printf("\n   ......:T R A B A L H O _ ESTRUTURA DE DADOS I_ V I A P I A N A:......   \n");
    printf("\n   ...........ALUNOS:   ...:Alison Rodrigues de Souza   92524@upf.br:...   \n");
    printf("\n                        ...:Jaqueline Pizzi Zilli       48793@upf.br:...   \n");
    printf("\n  _________________________________________________________________________\n");
    printf("\t\t\t  ________________\n");
    printf("\t\t\t  |              |\n ");
    printf("\t\t\t  | Digite ENTER |\n");
    printf("\t\t\t  |______________|\n");
    printf("\t\t\t  \n");
    fflush(stdin); getchar();
    system("cls");
}

/*..::Função que cria a pilhe de nodos disponiveis::..*/
void cria_pnd (void){
     int indice = 0;

     while( indice < TAMANHO - 1 ){
          lista[indice].elo_p = indice + 1;
          indice++;
     }
     lista[ TAMANHO - 1 ].elo_p = -1;
     disp = 0;
     printf("\nPilha de Nodos Disponiveis criada: \nPrecione ENTER para ir ao proximo passo!");
     fflush(stdin); getchar();
}

/*..::Função que obtem um indice::..*/
int obtem (void){
    int indice;

    if(disp == -1) /*..::a lista esta vazia?..::*/
         return( -1 );
    else{
         indice = disp;
         disp = lista[disp].elo_p;
    }
return(indice);
}

/*..::Função que cria o nodo-cabeça::..*/
void cria_nc (void){
     int nc;
     char aux[]="nodo-cabeca";

     nc = obtem(); /*..::obtem um indice disponivel::..*/

     lista[nc].elo_a = nc;
     lista[nc].elo_p = nc;
     strcpy(lista[nc].descricao, aux);
     printf("\nNodo-Cabeca criado: \nPrecione ENTER para ativar o MENU.\n");
     fflush(stdin); getchar();
}

/*..::Função menu::..*/
void menu ( char *p ){

        system("cls");

        printf("\n\t            ___________________________________________");
        printf("\n\t           |__--__--__--__....:MENU:....__--__--__--__|");
        printf("\n\t            ___________________________________________");
        printf("\n\t           |     I   -   ..:Inclusao:..               |");
        printf("\n\t           |     R   -   ..:Retirada:..               |");
        printf("\n\t           |     C   -   ..:Consulta:..               |");
        printf("\n\t           |     M   -   ..:Mostra Lista:. .          |");
        printf("\n\t           |     A   -   ..:Ordem Logica ELO_A:..     |");
        printf("\n\t           |     P   -   ..:Ordem Logica ELO_P:..     |");
        printf("\n\t           |     D   -   ..:Disponiveis:..            |");
        printf("\n\t           |     E   -   ..:Esvazia Lista:..          |");
        printf("\n\t           |     T   -   ..:Total:..                  |");
        printf("\n\t           |     F   -   ..:Fim:..                    |");
        printf("\n\t           |__________________________________________|");
        printf("\n\n\n\n\t           .......:Digite sua opcao: ");
        fflush(stdin);
        scanf("%c", p );

fflush(stdin);
}

/*..::Função que processa uma informação do menu::..*/
void processa_menu ( char *a ){

        *a = toupper( *a );
        switch( *a ){
           case 'I' : system("cls");
                      inclusao();
                      break;
           case 'C' : system("cls");
                      consulta();
                      break;
           case 'R' : system("cls");
                      retirada();
                      break;
           case 'M' : system("cls");
                      mostra_lista();
                      break;
           case 'A' : system("cls");
                      mostra_elo_a();
                      break;
           case 'P' : system("cls");
                      mostra_elo_p();
                      break;
           case 'D' : system("cls");
                      nodos_disp();
                      break;
           case 'E' : system("cls");
                      esvazia_lista();
                      break;
           case 'T' : system("cls");
                      total();
                      break;
           case 'F' : system("cls");
                      printf("Adios");
                      exit( 0 );
        }
}

/*..::Função que libera todos os nodos e os tornam disponiveis::..*/
void libera (int indice){
     char limpa[]="";

     lista[indice].elo_p = disp;
     disp = indice;
     /*..::limpa os nodos do indice excluido::..*/
     strcmp(lista[indice].descricao, limpa);
     lista[indice].quantidade = 0.00;
     strcmp(lista[indice].unidade, limpa);
     lista[indice].vlr_unitario = 0.00;
     lista[indice].elo_a = 0;
}

/*..::Função que inclui uma informação na lista::..*/
int inclusao (void){
    int indice;
    int anterior;
    int posterior;
    int n;
    int cont = 0;
    int i;

    if(disp == -1){
        printf("\n O V E R F L O W ! \nL I S T A    C H E I A \n");
        alerta();
        system("color 1f");
        fflush(stdin);
    }
    else{
        anterior = nc;
        posterior = lista[nc].elo_p;

        printf("Digite a Descricao : ");
        fflush(stdin); gets(aux_descricao);
        n = strlen(aux_descricao);
        while(cont <= n){
             aux_descricao[cont] = tolower(aux_descricao[cont]);
             cont++;
        }
        while (posterior != nc){
              if((strcmp(aux_descricao, lista[posterior].descricao) == 0)){
				   printf("Repetido!\n");
				   printf("\n\nTecle algo... ");
                   fflush(stdin); getchar(); return(0);
              }
              else{
                   anterior = posterior;
                   posterior = lista[posterior].elo_p;
              }
        }
        printf("Digite a Unidade : ");
        fflush(stdin); gets(aux_unidade);
        n = strlen(aux_unidade);
        cont = 0;
        while(cont <= n){
             aux_unidade[cont] = tolower(aux_unidade[cont]);
             cont++;
        }
        printf("Digite a Quantidade : ");
        fflush(stdin); scanf("%f", &aux_quantidade);
        printf("Digite o valor unitario do produto : ");
        fflush(stdin); scanf("%f", &aux_vlr_unitario);
        anterior = nc;
        posterior = lista[nc].elo_p;

        while(posterior != nc){
            if( strcmp(aux_descricao, lista[posterior].descricao) < 0)
                break;
            else{
                anterior= posterior;
                posterior = lista[posterior].elo_p;
            }
        }
        indice = obtem();
        /*..::copia informações das aux para a estrutura::..*/
        strcpy(lista[indice].descricao, aux_descricao);
        strcpy(lista[indice].unidade, aux_unidade);
        lista[indice].quantidade = aux_quantidade;
        lista[indice].vlr_unitario = aux_vlr_unitario;
        /*..::atualiza os nodos elos::..*/
        lista[anterior].elo_p = indice;
        lista[indice].elo_p = posterior;
        lista[posterior].elo_a = indice;
        lista[indice].elo_a = anterior;

        printf("\nIncluido com sucesso ! \n\n\nPrecione ENTER para voltar ao MENU: \n");
        fflush(stdin); getchar(); return(0);
    }
fflush(stdin);
}

/*..::Funcao que consulta uma informação na lista::..*/
void consulta (void){
     int aux;
     int i;
     int cont = 0;
     int n;

     aux = lista[nc].elo_p;

     if(lista[nc].elo_p == 0){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          }
     else{
          printf("Digite o nome a ser consultado : ");
          fflush(stdin); gets (aux_descricao);
          n = strlen(aux_descricao);
          while(cont <= n){
               aux_descricao[cont] = tolower(aux_descricao[cont]);
               cont++;
          }
          while(aux != nc){
               if(strcmp(aux_descricao, lista[aux].descricao) == 0)
                    break;
               else
                    aux = lista[aux].elo_p;
          }
          if(aux == nc)
             printf("valor nao encontrado na lista.\n\n");
          else
             printf("\nEncontrado no indice [%d]: %s\n\n", aux, lista[aux].descricao);
     printf("\n\n\nPrecione ENTER para voltar para o MENU:\n\n");
     fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao retira informação da lista::..*/
void retirada (void){
     char limpa[] = " ";
     int indice;
     int anterior;
     int posterior;
     int n;
     int cont = 0;
     int i;

     if(lista[nc].elo_p == nc){
          printf("U N D E R F L O W  \nL I S T A    V A Z I A !\n\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nDigite o nome da descricao a ser retirada da lista : ");
          fflush(stdin); gets (aux_descricao);
          n = strlen(aux_descricao);

          while(cont <= n){
                aux_descricao[cont] = tolower(aux_descricao[cont]);
                cont++;
          }
          anterior = nc;
          indice = lista[nc].elo_p;   

          while(indice != nc){
               if(strcmp(aux_descricao, lista[indice].descricao) == 0){
                    posterior = lista[indice].elo_p;
                    break;
               }
               else{
                    anterior = indice;
                    indice = lista[indice].elo_p;
               }
          }
          if(indice == nc)
               printf("Valor nao encontrado.\n");
          else{
               /*..::atualiza os nodos elos::..*/
               lista[anterior].elo_p = lista[indice].elo_p;
               lista[posterior].elo_a = lista[indice].elo_a;

               libera(indice);
               /*..::limpa os nodos::..*/
               strcpy(lista[indice].descricao, limpa);
               strcpy(lista[indice].unidade, limpa);
               lista[indice].quantidade = 0.00;
               lista[indice].vlr_unitario = 0.00;
               printf("\nRetirado com sucesso [ %s ] da lista da lista.\n", aux_descricao);
          }
          printf("\n\n\nPrecione ENTER para voltar para o MENU.\n");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao mostra elo A::..*/
void mostra_elo_a ( void ){
     int aux;
     int i;

     aux = lista[nc].elo_a;

     if(aux == nc){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nOrdem logica Elo_A");
          printf("\n\n\n    Elo A|  descricao");
          printf("\n|-------------------------------");
          while(aux != nc){
               printf("\n|%-8d| %-20s| ", lista[aux].elo_a, lista[aux].descricao);
               printf("\n|-------------------------------");

               aux = lista[aux].elo_a;
          }
          printf("\n\n\n\nPrecione ENTER para voltar ao MENU:");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao mostra elo P::..*/
void mostra_elo_p(void){
     int aux;
     int i;

     aux = lista[nc].elo_p;

     if( aux == nc ){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nOrdem logica Elo_P");
          printf("\n\n\n    Elo P|  descricao");
          printf("\n|-------------------------------");
          while(aux != nc){
               printf("\n|%-8d| %-20s| ", lista[aux].elo_p, lista[aux].descricao);
               printf("\n|-------------------------------");

               aux = lista[aux].elo_p;
          }
          printf("\n\n\n\nPrecione ENTER para voltar ao MENU:");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao nodos disponiveis::..*/
void nodos_disp (void){
     int aux;

     aux = disp;

     while( 1 ){
          if(aux == -1){
               printf("\nNao ha nodos disponiveis.\n");
               break;
          }
          else{
               printf("\n - [%d]", aux);

               if(lista[aux].elo_p == -1)
                  break;
               aux = lista[aux].elo_p;
          }
     }
printf("\nPrecione ENTER para voltar para o MENU:");
fflush(stdin); getchar();
}

/*..::Funcao mostra a lista::..*/
void mostra_lista( void ){
     int i;
     printf("\n              ELO A       DESCRICAO      UNIDAD  QTD   VLR UNIT   ELO P");
     printf("\n              ----------------------------------------------------------");
     for( i = 0 ; i ":(i == nc)?"NC---->":"" , i ,
               lista[i].elo_a , lista[i].descricao, lista[i].unidade, lista[i].quantidade, lista[i].vlr_unitario,
               lista[i].elo_p );
        printf("\n              ----------------------------------------------------------");
     }
     printf("\n\n\n\t\tNC: %2d\t\t\t\t\tDisp: %2d", nc, disp );
     fflush( stdin ); getchar();
}

/*..::Funcao esvazia a lista::..*/
void esvazia_lista( void ){
     char opcao;
     char limpa[]="";
     int aux;
     int i;

     if(lista[nc].elo_p == nc){
          printf("L I S T A    V A Z I A !");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("Tem certeza de que deseja esvaziar a lista?   [S/N] : \n");
          fflush(stdin); scanf("%c", &opcao);
          opcao = toupper(opcao);
          if(opcao == 'S'){

               aux = lista[nc].elo_p;

               printf("\nEsvaziando informacaes :\n");

               while(aux != 0){
                    system("cls");
                    printf("\n\nPrecione ENTER para excluir %s da lista:", lista[aux].descricao);
                    fflush(stdin); getchar();
                    strcpy(lista[aux].descricao, limpa);
                    strcpy(lista[aux].unidade, limpa);
                    lista[aux].elo_a = nc;
                    lista[aux].quantidade = 0.00;
                    lista[aux].vlr_unitario = 0.00;
                    aux = lista[aux].elo_p;
               }
               printf("\nLista esvaziada !\n\n");
               cria_pnd();
               cria_nc();
          }
     }
}

/*..::Funcao total::..*/
void total (void){
     int aux;
     int i;

     aux = lista[nc].elo_p;
     if(lista[nc].elo_p == 0){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          aux_quantidade = 0.00;
          aux_vlr_unitario = 0.00;
          while(aux != nc){
                if(aux != nc){
                     aux_quantidade += lista[aux].quantidade;
                     aux_vlr_unitario += lista[aux].vlr_unitario;
                }
                aux = lista[aux].elo_p;
          }
     printf("\n\tT O T A L\n");
     printf("\n|----------------------------|");
     printf("\n| Quantidade  |  Vlr Unitario|");
     printf("\n|----------------------------|");
     aux = lista[nc].elo_p;
     printf("\n|%13.2f|%14.2f| ", aux_quantidade, aux_vlr_unitario);
     printf("\n|----------------------------|");
     printf("\n\n\nPrecione ENTER para voltar para o MENU: ");
     fflush(stdin); getchar();
     }
fflush(stdin);
}

  /**************************************************************************
   * (C) Copyright 2008 by Alison & Jaqueline.                              *
   * All Rights Reserved.                                                   *
   *                                                                        *
   *            ....::::trabalho de estrutura de dados::::....              *
   *               ....::::Alison Rodrigues de Souza::::....                *
   *                 ....::::Jaqueline Pizzi Zilli::::....                  *
   *************************************************************************/

Flw pessoal.