C problema com exercicio de lista encadeada

[Engenharia2020]

Olá sou novo aqui! 

Preciso de uma ajuda com um exercicio

Tenho dois exercicios de programação em C sobre LISTA ENCADEADA,

mas tem um exercicio que não estou conseguindo terminar.

agradeço quem puder me ajudar 

 

 

 

*Exercicio

Um banco precisa com frequência inserir, remover, ordenar, exibir e zerar seus clientes de acordo com algum critério.

Neste trabalho, você deverá implementar um sistema que permita ao funcionário do banco ordenar os clientes do banco pelo seu saldo (em ordem decrescente)

ou pelo número da conta do cliente (por ordem crescente). Os dados dos clientes a serem inseridos devem conter para cada cliente,

o seu nome, número da conta (número inteiro positivo de até 5 dígitos) e saldo.

 

deve conter os seguintes menus: - Inserção,

                                                      - Remoção,

                                                      - Ordenação,

                                                      - Exibir Lista,

                                                      - Zerar Lista

 

struct Banco {

int  numero_conta;

char  nome_cliente  [30]; float  saldo;

Banco  *prox; Banco  *ant;

};

typedef  struct  Banco  node;

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

[Visitante]

@Engenharia2020 Olá. Daria para postar o código todo? Ajudaria muito para uma resposta mais precisa de alguém aqui do fórum

[Engenharia2020]

Em 12/09/2018 às 23:07, giu_d disse:

@Engenharia2020 Olá. Daria para postar o código todo? Ajudaria muito para uma resposta mais precisa de alguém aqui do fórum

Ola! sim esta aqui

 

 

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

 typedef struct lista{
     int numero_conta;
     char nome_cliente[40];
     float saldo;
     struct lista* prox;
   }Lista;

//Declaração de funções.
   Lista* inserir_cadastros(Lista* primeiro);
   void listar_cadastros(Lista* primeiro);
   Lista* excluir_cadastros(Lista* primeiro);
   void alterar_cadastros(Lista* primeiro);

   main()   {

//Declaração de variáveis
   Lista *primeiro= NULL;
   char opcao;

//Artifício para repetir o programa.
   while(opcao!='s')
   {

//Menu de opções
      printf(" %c----------------------------------------------------------------------------%c\n",201,187);
      printf(" | ");printf("\t\t\t     CADASTRO DE CLIENTES");printf("\t\t\t      |\n");
      printf(" %c----------------------------------------------------------------------------%c\n",200,188);
      printf("\t       %c----------%c\t\t\t\t       ",201,187);
      printf("\t\t\t               |   MENU   ");printf("|\t\t\t\t      \n");
      printf("   %c-----------%c----------%c------------%c \n",201,200,188,187);
      printf("   | <A>  Nova Conta                   |\n");
      printf("   |-----------------------------------|\n");
      printf("   | <B>  Relatorio                    |\n");
      printf("   |-----------------------------------|\n");
      printf("   | <C>  Excluir cadastro             |\n");
      printf("   |-----------------------------------|\n");
      printf("   | <D>  Alterar cadastro             |\n");
      printf("   |-----------------------------------|\n");
      printf("   | <S>  Sair                         |\n");
      printf("   %c-----------------------------------%c",200,188);
      printf("\n\n\n\n");

//Lendo a opcao do menu
      fflush(stdin);
      opcao= getch();

//Menu de opções
      switch(opcao)
      {
         case 'A':
         case 'a':
//Inserindo a Conta.
              fflush(stdin);
              system("cls");
              printf(" %c----------------------------------------------------------------------------%c\n",201,187);
              printf(" | ");printf("\t\t\t          NOVO CADASTRO     ");printf("\t\t\t      |\n");
              printf(" %c----------------------------------------------------------------------------%c\n",200,188);
              primeiro= inserir_cadastros(primeiro);
         getch();
         system("cls");
         break;

         case 'B':
         case 'b':

//Listando os Cadastros.
              system ("cls");
              printf(" %c----------------------------------------------------------------------------%c\n",201,187);
              printf(" | ");printf("\t\t\t     CONTAS CADASTRADAS");printf("\t\t\t      |\n");
              printf(" %c----------------------------------------------------------------------------%c\n",200,188);
              listar_cadastros(primeiro);
         getch();
         system("cls");
         break;

         case 'C':
         case 'c':

//Excluindo contas do cadastro.
              system ("cls");
              printf(" %c----------------------------------------------------------------------------%c\n",201,187);
              printf(" | ");printf("\t\t\t        EXCLUIR CADASTROS");printf("\t\t\t      |\n");
              printf(" %c----------------------------------------------------------------------------%c\n",200,188);
              primeiro= excluir_cadastros(primeiro);
         getch();
         system("cls");
         break;

         case 'D':
         case 'd':

//Alterando contas do cadastro.
              system ("cls");
              printf(" %c----------------------------------------------------------------------------%c\n",201,187);
              printf(" | ");printf("\t\t\t       ALTERAR CADASTRADOS");printf("\t\t\t      |\n");
              printf(" %c----------------------------------------------------------------------------%c\n",200,188);
              alterar_cadastros(primeiro);
         getch();
         system("cls");
         break;

         case 'S':
         case 's':

//Artifício para sair do programa.
         opcao='s';
         break;

         default:
//Artifício que previne a situação de um usuário qualquer, digitar uma opcão inexistente no menu.
        system("cls");
         break;
      }
   }
}
Lista* inserir_cadastros(Lista* primeiro);
     Lista cliente;
     Lista *atual= primeiro;
     char identificador= 'F';

//Lendo as informações do cliente.

     printf("  Numero da Conta: ",162);
     scanf("%u",&cliente.numero_conta);printf ("\n");
     printf("  Nome: ");
     fflush (stdin); fgets(cliente.nome_cliente, 40, stdin); printf ("\n");
     printf("  Saldo: ",162);
     scanf("%u",&cliente.saldo);printf ("\n");

//Verificando se o cadastro já existe.
    for(atual=primeiro; atual!=NULL; atual=atual->prox){
    if(atual->numero_conta==cliente.numero_conta){
    identificador= 'V';
    break;
            }
     }

    if(identificador!='V' && (strlen(cliente.nome_cliente)!=1 && strlen(cliente.saldo)!=1)){

//Alocando os espaços e guardando as informações do cliente.
         Lista* NovoCliente=(Lista*) malloc (sizeof(Lista));
         strcpy(NovoCliente->nome, cliente.nome_cliente);
         strcpy(NovoCliente->endereco, cliente.saldo);
         NovoCliente->numero_conta= cliente.numero_conta;
         NovoCliente->prox= primeiro;
         printf("  Cadastro realizado com sucesso.");
         printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
         return NovoCliente;
     }else{
         printf("  Cadastro invalido.",160);
         printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
         return primeiro;
     }
}

void listar_cadastros(Lista* primeiro){
     Lista* atual;//Ponteiro para percorrer a lista sem perder a referência do primeiro elemento da lista.

//Imprimindo os restaurantes da lista, e suas repectivas informações.
     for(atual= primeiro ; atual!= NULL; atual= atual->prox){

        printf("\n  Conta: ",162 );
        printf("%u", atual->numero_conta);
        printf("\n  Nome: ");
        printf("%s", atual->nome_cliente);
        printf("\n  Saldo: ",135);
        printf("%s", atual->saldo);
        printf("\n\n");
     }
     if(primeiro==NULL)
        printf("  Nenhum Cliente Cadastrado.");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}

Lista* excluir_cadastros(Lista* primeiro){

     Lista *anterior= NULL;//Ponteiro para saber o elemento anterior ao elemento atual da lista.
     Lista *atual= primeiro;//Ponteiro para percorrer a lista sem perder o primeiro elemento da lista.
     int numero_conta=0;

//Requisitando e lendo o código do cliente a ser excluído.
     printf("  Codigo do cliente a ser excluido: ", 162,161);
     fflush(stdin);
     scanf("%u",&numero_conta);

//Procurando o cliente na lista.
     while(atual!= NULL && atual->numero_conta!=numero_conta){
     anterior= atual;
     atual= atual->prox;
     }

//Mensagem caso o cliente não seja encontrado.
     if(atual==NULL){
        printf("\n  Cliente não encontrado.", 198);
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return primeiro;
     }

//Excluindo o primeiro cliente da lista.
     if(anterior==NULL){
        printf("\n  Conteudo excluido com sucesso.", 163,161);
        primeiro= atual->prox;
//Excluindo um cliente do meio da lista.
     }else{
        printf("\n  Conteudo excluido com sucesso.", 163,161);
        anterior->prox= atual->prox;
     }

//Desalocando o espaço da memória.
     free(atual);
     printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
     return primeiro;
}

//Função para alterar cadastros.
void alterar_cadastros(Lista* primeiro);{
     int numero_contasub;
     char nome_substituto[40],
     float saldo_sub;;
     Lista* atual=primeiro;

//Requisitando e lendo o código do cliente a ser alterado.
     printf("  Codigo do cliente a ser alterado: ", 162);
     fflush(stdin);
     scanf("%u",&numero_contasub);

//Procurando o cliente na lista.
     while(atual!= NULL && atual->numero_contasub!=numero_contasub){
     atual= atual->prox;
     }

//Alterando os dados do cliente.
     if(atual!=NULL){
        printf("\n  Novo nome: ");
        fflush (stdin); fgets(nome_substituto, 40, stdin);
        strcpy(atual->nome,nome_substituto);
        printf("\n  Novo Saldo: ",135);
        fflush (stdin); fgets(saldo_sub, 40, stdin); printf ("\n");
        strcpy(atual->endereco,saldo_sub);
        printf("  Dados alterados com sucesso.");
     }else{
        printf("\n  Cliente nao encontrado.",198);
     }
     printf("\n\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}
 

[Visitante]

@Engenharia2020 Olá. Resolvi dar um "tapinha" no seu código até por gostar muito de trabalhar com lista encadeada

Só gostaria de frisar o seguinte: Do modo como você está inserindo na lista um novo cadastro, você está inserindo no início da lista, dessa forma, se você inserir os elementos 1, 2 e 3, sua lista ficará assim -> 3, 2, 1

A dica que dou é inserir no final da lista, pois se inserir os mesmos elementos 1, 2 e 3, sua lista passará a ficar assim -> 1, 2, 3

Deu para perceber a diferença? 

Claro que é apenas uma sugestão, pois do modo como está sendo feito o exercício está bom, com exceção de alguns 'bugs' que não deveriam estar ali, como erros de sintaxe, por exemplo rs...

Não implementei outras funcionalidades no código, a pena procurei ajustar o código passado por você

Testa aí para ver se tá tudo ok!

Obs: No final do post vou te mandar um tutorial que gosto muito e tem me ajudado muito a entender melhor sobre lista encadeada

Também não recomendo de forma alguma o uso do comando fflush(stdin);. Esse comando tem um comportamento imprevisível quando se trata de limpa o buffer da entrada padrão (teclado) e estou passando uma função muito útil e eficaz para substituir esse comando. Vou ser sincero, nós aqui do fórum não fazemos uso desse comando fflush(stdin); pela questão q mencionei

Segue o código:

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

typedef struct lista {
    int numero_conta;
    char nome_cliente[40];
    float saldo;
    struct lista* prox;
} Lista;

//Declaração de funções.
Lista* inserir_cadastros(Lista* primeiro);
void listar_cadastros(Lista* primeiro);
Lista* excluir_cadastros(Lista* primeiro);
void alterar_cadastros(Lista* primeiro);
void limpa_linha(void); // função para limpar a sujeira no buffer

int main() {

//Declaração de variáveis
    Lista *primeiro= NULL;
    char opcao;

//Artifício para repetir o programa.
    while(opcao!='s')
    {

//Menu de opções
        printf(" %c----------------------------------------------------------------------------%c\n",201,187);
        printf(" | ");
        printf("\t\t\t     CADASTRO DE CLIENTES");
        printf("\t\t\t      |\n");
        printf(" %c----------------------------------------------------------------------------%c\n",200,188);
        printf("\t       %c----------%c\t\t\t\t       ",201,187);
        printf("\t\t\t               |   MENU   ");
        printf("|\t\t\t\t      \n");
        printf("   %c-----------%c----------%c------------%c \n",201,200,188,187);
        printf("   | <A>  Nova Conta                   |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <B>  Relatorio                    |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <C>  Excluir cadastro             |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <D>  Alterar cadastro             |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <S>  Sair                         |\n");
        printf("   %c-----------------------------------%c",200,188);
        printf("\n\n\n\n");
//Lendo a opcao do menu
        opcao = getch();

//Menu de opções
        switch(opcao)
        {
        case 'A':
        case 'a':
//Inserindo a Conta.
            fflush(stdin);
            system("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t          NOVO CADASTRO     ");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            primeiro= inserir_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'B':
        case 'b':
//Listando os Cadastros.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t     CONTAS CADASTRADAS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            listar_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'C':
        case 'c':
//Excluindo contas do cadastro.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t        EXCLUIR CADASTROS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            primeiro= excluir_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'D':
        case 'd':
//Alterando contas do cadastro.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t       ALTERAR CADASTRADOS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            alterar_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'S':
        case 's':
//Artifício para sair do programa.
            opcao='s';
            break;
        default:
//Artifício que previne a situação de um usuário qualquer, digitar uma opcão inexistente no menu.
            system("cls");
            break;
        }
    }
}

void limpa_linha() {
    scanf("%*[^\n]");
    scanf("%*c");
}

Lista* inserir_cadastros(Lista* primeiro) {

    Lista cliente;
    Lista *atual = primeiro;
    char identificador = 'F';

    //Lendo as informações do cliente.
    printf("  Numero da Conta: ");
    scanf("%d", &cliente.numero_conta);
    limpa_linha();
    printf ("\n");
    printf("  Nome: ");
    fgets(cliente.nome_cliente, 40, stdin);
    printf ("\n");
    printf("  Saldo: ");
    scanf("%f", &cliente.saldo);
    limpa_linha();

    printf ("\n");

    //Verificando se o cadastro já existe.
    for (atual = primeiro; atual != NULL; atual = atual->prox) {
        if (atual->numero_conta == cliente.numero_conta) {
            identificador = 'V';
            break;
        }
    }

    if ( identificador != 'V' && (strlen(cliente.nome_cliente) != 1)) {

        //Alocando os espaços e guardando as informações do cliente.
        Lista* NovoCliente = malloc (sizeof(Lista));
        strcpy(NovoCliente->nome_cliente, cliente.nome_cliente);
        NovoCliente->saldo = cliente.saldo;
        NovoCliente->numero_conta = cliente.numero_conta;
        NovoCliente->prox = primeiro;
        printf("  Cadastro realizado com sucesso.");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return NovoCliente;
    } else {
        printf("  Cadastro invalido!");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return primeiro;
    }
}


void listar_cadastros(Lista* primeiro) {

    Lista* atual;//Ponteiro para percorrer a lista sem perder a referência do primeiro elemento da lista.

    //Imprimindo os restaurantes da lista, e suas repectivas informações.
    for (atual = primeiro ; atual != NULL; atual = atual->prox) {
        printf("\n  Conta: ");
        printf("%d", atual->numero_conta);
        printf("\n  Nome: ");
        printf("%s", atual->nome_cliente);
        printf("  Saldo: ");
        printf("%.2f", atual->saldo);
        printf("\n\n");
    }
    if ( primeiro == NULL)
        printf("  Nenhum Cliente Cadastrado.");
    printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}

Lista* excluir_cadastros(Lista* primeiro) {

    Lista *anterior = NULL;//Ponteiro para saber o elemento anterior ao elemento atual da lista.
    Lista *atual = primeiro;//Ponteiro para percorrer a lista sem perder o primeiro elemento da lista.
    int numero_conta = 0;

//Requisitando e lendo o código do cliente a ser excluído.
    printf("  Codigo do cliente a ser excluido: ");
    scanf("%d",&numero_conta);
    limpa_linha();

//Procurando o cliente na lista.
    while( atual != NULL && atual->numero_conta != numero_conta) {
        anterior = atual;
        atual = atual->prox;
    }

//Mensagem caso o cliente não seja encontrado.
    if (atual == NULL) {
        printf("\n  Cliente nao encontrado.");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return primeiro;
    }

//Excluindo o primeiro cliente da lista.
    if (anterior == NULL) {
        printf("\n  Conteudo excluido com sucesso.");
        primeiro= atual->prox;
//Excluindo um cliente do meio da lista.
    } else {
        printf("\n  Conteudo excluido com sucesso.");
        anterior->prox= atual->prox;
    }

//Desalocando o espaço da memória.
    free(atual);
    printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
    return primeiro;
}

//Função para alterar cadastros.
void alterar_cadastros(Lista *primeiro) {

    int numero_contasub;
    char nome_substituto[40];
    float saldo_sub;
    Lista *atual = primeiro;
    int encontrado;

    //Requisitando e lendo o código do cliente a ser alterado.
    printf("  Codigo do cliente a ser alterado: ");
    scanf("%d", &numero_contasub);
    limpa_linha();

    encontrado = 0;
    // Busca pelo cadastro
    for (atual = primeiro; atual != NULL; atual = atual->prox) {
        if (atual->numero_conta == numero_contasub) {
            encontrado = 1;
            printf("\n  Novo nome: ");
            fgets(nome_substituto, 40, stdin);
            strcpy(atual->nome_cliente, nome_substituto);
            printf("\n  Novo Saldo: ");
            scanf("%f", &saldo_sub);
            limpa_linha();
            printf ("\n");
            atual->saldo = saldo_sub;
            printf("Dados alterados com sucesso!");
        }
    }
    if (!encontrado) {
        printf("\nCliente nao encontrado!");
    }

    printf("\n\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}

Teria que testar bem para ver se tá tudo ok!

Segue o tutorial que acredito que vai t ajudar muito a entender melhor sobre lista encadeada e, se quiser, até seguir a sugestão que passei acima, de inserir os novos cadastros no final da lista:

Cap 10 - Lista Encadeada.pdf

Qualquer dúvida é só perguntar! 

[Engenharia2020]

16 horas atrás, giu_d disse:

@Engenharia2020 Olá. Resolvi dar um "tapinha" no seu código até por gostar muito de trabalhar com lista encadeada

Só gostaria de frisar o seguinte: Do modo como você está inserindo na lista um novo cadastro, você está inserindo no início da lista, dessa forma, se você inserir os elementos 1, 2 e 3, sua lista ficará assim -> 3, 2, 1

A dica que dou é inserir no final da lista, pois se inserir os mesmos elementos 1, 2 e 3, sua lista passará a ficar assim -> 1, 2, 3

Deu para perceber a diferença? 

Claro que é apenas uma sugestão, pois do modo como está sendo feito o exercício está bom, com exceção de alguns 'bugs' que não deveriam estar ali, como erros de sintaxe, por exemplo rs...

Não implementei outras funcionalidades no código, a pena procurei ajustar o código passado por você

Testa aí para ver se tá tudo ok!

Obs: No final do post vou te mandar um tutorial que gosto muito e tem me ajudado muito a entender melhor sobre lista encadeada

Também não recomendo de forma alguma o uso do comando fflush(stdin);. Esse comando tem um comportamento imprevisível quando se trata de limpa o buffer da entrada padrão (teclado) e estou passando uma função muito útil e eficaz para substituir esse comando. Vou ser sincero, nós aqui do fórum não fazemos uso desse comando fflush(stdin); pela questão q mencionei

Segue o código:

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

typedef struct lista {
    int numero_conta;
    char nome_cliente[40];
    float saldo;
    struct lista* prox;
} Lista;

//Declaração de funções.
Lista* inserir_cadastros(Lista* primeiro);
void listar_cadastros(Lista* primeiro);
Lista* excluir_cadastros(Lista* primeiro);
void alterar_cadastros(Lista* primeiro);
void limpa_linha(void); // função para limpar a sujeira no buffer

int main() {

//Declaração de variáveis
    Lista *primeiro= NULL;
    char opcao;

//Artifício para repetir o programa.
    while(opcao!='s')
    {

//Menu de opções
        printf(" %c----------------------------------------------------------------------------%c\n",201,187);
        printf(" | ");
        printf("\t\t\t     CADASTRO DE CLIENTES");
        printf("\t\t\t      |\n");
        printf(" %c----------------------------------------------------------------------------%c\n",200,188);
        printf("\t       %c----------%c\t\t\t\t       ",201,187);
        printf("\t\t\t               |   MENU   ");
        printf("|\t\t\t\t      \n");
        printf("   %c-----------%c----------%c------------%c \n",201,200,188,187);
        printf("   | <A>  Nova Conta                   |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <B>  Relatorio                    |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <C>  Excluir cadastro             |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <D>  Alterar cadastro             |\n");
        printf("   |-----------------------------------|\n");
        printf("   | <S>  Sair                         |\n");
        printf("   %c-----------------------------------%c",200,188);
        printf("\n\n\n\n");
//Lendo a opcao do menu
        opcao = getch();

//Menu de opções
        switch(opcao)
        {
        case 'A':
        case 'a':
//Inserindo a Conta.
            fflush(stdin);
            system("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t          NOVO CADASTRO     ");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            primeiro= inserir_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'B':
        case 'b':
//Listando os Cadastros.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t     CONTAS CADASTRADAS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            listar_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'C':
        case 'c':
//Excluindo contas do cadastro.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t        EXCLUIR CADASTROS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            primeiro= excluir_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'D':
        case 'd':
//Alterando contas do cadastro.
            system ("cls");
            printf(" %c----------------------------------------------------------------------------%c\n",201,187);
            printf(" | ");
            printf("\t\t\t       ALTERAR CADASTRADOS");
            printf("\t\t\t      |\n");
            printf(" %c----------------------------------------------------------------------------%c\n",200,188);
            alterar_cadastros(primeiro);
            getch();
            system("cls");
            break;
        case 'S':
        case 's':
//Artifício para sair do programa.
            opcao='s';
            break;
        default:
//Artifício que previne a situação de um usuário qualquer, digitar uma opcão inexistente no menu.
            system("cls");
            break;
        }
    }
}

void limpa_linha() {
    scanf("%*[^\n]");
    scanf("%*c");
}

Lista* inserir_cadastros(Lista* primeiro) {

    Lista cliente;
    Lista *atual = primeiro;
    char identificador = 'F';

    //Lendo as informações do cliente.
    printf("  Numero da Conta: ");
    scanf("%d", &cliente.numero_conta);
    limpa_linha();
    printf ("\n");
    printf("  Nome: ");
    fgets(cliente.nome_cliente, 40, stdin);
    printf ("\n");
    printf("  Saldo: ");
    scanf("%f", &cliente.saldo);
    limpa_linha();

    printf ("\n");

    //Verificando se o cadastro já existe.
    for (atual = primeiro; atual != NULL; atual = atual->prox) {
        if (atual->numero_conta == cliente.numero_conta) {
            identificador = 'V';
            break;
        }
    }

    if ( identificador != 'V' && (strlen(cliente.nome_cliente) != 1)) {

        //Alocando os espaços e guardando as informações do cliente.
        Lista* NovoCliente = malloc (sizeof(Lista));
        strcpy(NovoCliente->nome_cliente, cliente.nome_cliente);
        NovoCliente->saldo = cliente.saldo;
        NovoCliente->numero_conta = cliente.numero_conta;
        NovoCliente->prox = primeiro;
        printf("  Cadastro realizado com sucesso.");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return NovoCliente;
    } else {
        printf("  Cadastro invalido!");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return primeiro;
    }
}


void listar_cadastros(Lista* primeiro) {

    Lista* atual;//Ponteiro para percorrer a lista sem perder a referência do primeiro elemento da lista.

    //Imprimindo os restaurantes da lista, e suas repectivas informações.
    for (atual = primeiro ; atual != NULL; atual = atual->prox) {
        printf("\n  Conta: ");
        printf("%d", atual->numero_conta);
        printf("\n  Nome: ");
        printf("%s", atual->nome_cliente);
        printf("  Saldo: ");
        printf("%.2f", atual->saldo);
        printf("\n\n");
    }
    if ( primeiro == NULL)
        printf("  Nenhum Cliente Cadastrado.");
    printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}

Lista* excluir_cadastros(Lista* primeiro) {

    Lista *anterior = NULL;//Ponteiro para saber o elemento anterior ao elemento atual da lista.
    Lista *atual = primeiro;//Ponteiro para percorrer a lista sem perder o primeiro elemento da lista.
    int numero_conta = 0;

//Requisitando e lendo o código do cliente a ser excluído.
    printf("  Codigo do cliente a ser excluido: ");
    scanf("%d",&numero_conta);
    limpa_linha();

//Procurando o cliente na lista.
    while( atual != NULL && atual->numero_conta != numero_conta) {
        anterior = atual;
        atual = atual->prox;
    }

//Mensagem caso o cliente não seja encontrado.
    if (atual == NULL) {
        printf("\n  Cliente nao encontrado.");
        printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
        return primeiro;
    }

//Excluindo o primeiro cliente da lista.
    if (anterior == NULL) {
        printf("\n  Conteudo excluido com sucesso.");
        primeiro= atual->prox;
//Excluindo um cliente do meio da lista.
    } else {
        printf("\n  Conteudo excluido com sucesso.");
        anterior->prox= atual->prox;
    }

//Desalocando o espaço da memória.
    free(atual);
    printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
    return primeiro;
}

//Função para alterar cadastros.
void alterar_cadastros(Lista *primeiro) {

    int numero_contasub;
    char nome_substituto[40];
    float saldo_sub;
    Lista *atual = primeiro;
    int encontrado;

    //Requisitando e lendo o código do cliente a ser alterado.
    printf("  Codigo do cliente a ser alterado: ");
    scanf("%d", &numero_contasub);
    limpa_linha();

    encontrado = 0;
    // Busca pelo cadastro
    for (atual = primeiro; atual != NULL; atual = atual->prox) {
        if (atual->numero_conta == numero_contasub) {
            encontrado = 1;
            printf("\n  Novo nome: ");
            fgets(nome_substituto, 40, stdin);
            strcpy(atual->nome_cliente, nome_substituto);
            printf("\n  Novo Saldo: ");
            scanf("%f", &saldo_sub);
            limpa_linha();
            printf ("\n");
            atual->saldo = saldo_sub;
            printf("Dados alterados com sucesso!");
        }
    }
    if (!encontrado) {
        printf("\nCliente nao encontrado!");
    }

    printf("\n\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");
}

Teria que testar bem para ver se tá tudo ok!

Segue o tutorial que acredito que vai t ajudar muito a entender melhor sobre lista encadeada e, se quiser, até seguir a sugestão que passei acima, de inserir os novos cadastros no final da lista:

Cap 10 - Lista Encadeada.pdf

Qualquer dúvida é só perguntar! 

Cara, nem acredito q você conseguiu me ajudar!

Muito Obrigado de verdade!!!

 

Outra duvida!

como seria o caso de ordenação?

se no caso apos cadastrados os clientes, eu querer selecionar o relatorio e ordenar por saldo de maior p/ o menos.

seria direcionado os ponteiros?

[Visitante]

@Engenharia2020 Olá. Sobre ordenação recomendo dar uma olhada nesse tutorial:

Só que é o seguinte: Testei aqui e até ordena certo pelo saldo usando a mesma lógica que é mostrada nesse tutorial que recomendei, mas ao fazer alguma alteração aí da uma bagunça grande. Ou seja: Continua ordenando por saldo, mas o saldo de um passa a ser o saldo de outro e por aí vai. O mesmo ocorre quando é feita uma remoção 

[Engenharia2020]

Entendi!

Mas você acha melhor mudar toda a estrutura dele entao?

[Visitante]

@Engenharia2020 Acredito que o problema está na minha função para ordenar mesmo

Segue o código da mesma:

Lista *ordenar(Lista *primeiro) {

    Lista *p = primeiro;
    Lista *t;
    float c;

    if (primeiro == NULL || primeiro->prox == NULL)
        return NULL;

    while (p != NULL) {
        t = p->prox;
        while (t != NULL) {
            if (p->saldo < t->saldo) {
                c = p->saldo;
                p->saldo = t->saldo;
                t->saldo = c;
            }
            t = t->prox;
        }
        p = p->prox;
    }

    return primeiro;
}

Devo confessar que trabalhei pouco com ordenação em lista encadeada, logo, é muito provável que o problema esteja nessa função ordenar. O que ocorre é que ela está ordenando somente o saldo, e não os outros elementos da lista, nome e número da conta, entendeu? 

O restante do código está funcionando tudo ok

[Engenharia2020]

E no caso de duplamente encadeada faz alguma diferença na ordenação?

[Visitante]

@Engenharia2020 Pelo que pesquisei, encontrei um comentário que dizia que ordenação em lista duplamente encadeada é mais fácil. Só que não sei dizer se é isso mesmo

Estou certo já que o problema é na minha função mesmo

OBS: Recomendo pesquisar a respeito ou, quem sabe, algum colega aqui do fórum possa ajudar quanto a essa questão de ordenação  

Mas vou tratar de pesquisar também a respeito, té porque gostaria de aprender bem a respeito disso e, se tiver algum sucesso, posto aqui, ok?

[Engenharia2020]

beleza! sem problemas

ja me ajudou bastante  mesmo

vou ver a respeito disso

Muito Obrigado!

[Visitante]

@Engenharia2020 Só que é o seguinte. Também teria que repensar a respeito da função para alterar um registro, como, por exemplo, ao invés de ela ser do tipo void,  retornar a lista atualizada com a alteração feita. Considere isso também!

Se você usar essa função para ordenar e somente inserir registros e depois ordenar dá tudo certo, porém, se é feita uma alteração aí da uma raba geral

Só que agora tenho que sair, mas vou continuar trabalhando no código depois ou, se der, amanhã 

[Engenharia2020]

Vixi, entendi quase nada o q você falou kkkkk

mesmo assim fico muito grato pela ajuda.

 

[Visitante]

@Engenharia2020 Olá. A ideia foi esse mudança na função para alterar um cadastro:

//Função para alterar cadastros.
Lista* alterar_cadastros(Lista *primeiro) {

    int numero_contasub;
    char nome_substituto[40];
    float saldo_sub;
    Lista *atual = primeiro;
    int encontrado;

    //Requisitando e lendo o código do cliente a ser alterado.
    printf("  Codigo do cliente a ser alterado: ");
    scanf("%d", &numero_contasub);
    limpa_linha();

    encontrado = 0;
    // Busca pelo cadastro
    for (atual = primeiro; atual != NULL; atual = atual->prox) {
        if (atual->numero_conta == numero_contasub) {
            encontrado = 1;
            printf("\n  Novo nome: ");
            fgets(nome_substituto, 40, stdin);
            strcpy(atual->nome_cliente, nome_substituto);
            printf("\n  Novo Saldo: ");
            scanf("%f", &saldo_sub);
            limpa_linha();
            printf ("\n");
            atual->saldo = saldo_sub;
            printf("Dados alterados com sucesso!");
        }
    }
    if (!encontrado) {
        printf("\nCliente nao encontrado!");
    }

    printf("\n\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");

    return primeiro; // retorna a lista atualizada
}

Só que o problema está de fato na função ordena 

adicionado 35 minutos depois

@Engenharia2020 Cara, parti da seguinte lógica. A função para ordenar estava só ordenando os saldos, logo resolvi também na função ordenar os nomes e números da conta, e ao que parece foi pelo que testei aqui!

Teria que testar bem

Obs: Não sei se é o melhor algoritmo para ordenar uma lista como essa, mas até onde testei tá tudo ok!

Segue a função atualizada:

Lista *ordenar(Lista *primeiro) {

    Lista *p = primeiro;
    Lista *t;
    float c;
    char nome_aux[40];
    int n;

    if (primeiro == NULL || primeiro->prox == NULL)
        return NULL;

    while (p != NULL) {
        t = p->prox;
        while (t != NULL) {
            if (p->saldo < t->saldo) {
                // ordena os saldos
                c = p->saldo;
                p->saldo = t->saldo;
                t->saldo = c;
                // ordena os nomes
                strcpy(nome_aux, p->nome_cliente);
                strcpy(p->nome_cliente, t->nome_cliente);
                strcpy(t->nome_cliente, nome_aux);
                // ordena os numeros das contas
                n = p->numero_conta;
                p->numero_conta = t->numero_conta;
                t->numero_conta = n;
            }
            t = t->prox;
        }
        p = p->prox;
    }

    printf("\n Lista ordenada!");
    printf("\n\n  PRESSIONE QUALQUER TECLA PARA VOLTAR AO MENU PRINCIPAL.");

    return primeiro;
}

Yeahhhh! Tô comemorando aqui baseado nos testes que fiz 

Vê se está tudo ok para garantir

Aguardo a resposta para comemorar p valer rs...

Se ficar em dúvida como usar essa função é só perguntar, mas seria tal como a função para alterar e excluir um registro da lista:

case 'O':
case 'o':
    primeiro = ordenar(primeiro);
    getch();
    system("cls");
    break;

 

[Engenharia2020]

Estava tentando acrecentar a parte de ordenação mas não sei no q estou errando,

esta dando varios erros.

adicionado 24 minutos depois

antes de continuar,voltei para dar uma olhada no trabalho q ele passou

acredito q 80% ja atende o que o professou pediu

mas eu reparei q ele colocou na declaração. 

   struct Banco {
           int numero_conta;
           char nome_cliente [30]; float saldo;
           Banco *prox;

           Banco *ant;    (q parece ser uma dupla mesmo)

 

q agora fiquei em duvida se vai condenar tudo q foi feito até agora 

estou colocando em anexo o exercício proposto para ver se a estrutura esta certa e qual deve ser modificava

Trabalho de Algoritmos e Estrutura de Dados.pdf

[Visitante]

@Engenharia2020 É amigo. Essa seria uma lista duplamente encadeada, segundo o enunciado

Mas não esquenta não. Quanto ao código q você postou se trata de uma lista encadeada (simples) e estou feliz por ter resolvido o mesmo. Adquiri mais experiência com isso.

Só que vejo que vai ser preciso você refazer todo o exercício 

Também tenho uma parcela de "culpa" por ter ter analisado o enunciado de modo correto

[Engenharia2020]

Sem Problemas! Agradeço pela ajuda

vou refazer o codigo aqui e caso tenha ou tra duvida eu volto

Obrigado!

[Visitante]

@Engenharia2020 Cara, recomendo antes de qualquer coisa dar uma olhada no tutorial que te passei. Nele é falado alguma coisa sobre lista duplamente encadeada e creio que vai te ajudar muito! 

[Visitante]

@Engenharia2020 Olá. Já vou te dar boas notícias. Apenas com uma revisão que eu fiz sobre lista duplamente encadeada de um Curso de C que fiz e procurando entender o que é mostrado no tutorial que te passei sobre o assunto, deu para resolver o exercício sem maiores problemas. 

Claro que devo confessar que, por não estar tão familiarizado com relação a lista duplamente encadeada, inda vou ter que estudar mais a respeito disso. Mas já foi um ponto de partida para passar a entender sobre o assunto

Claro que postar o exercício resolvido aqui vai contra as regras do fórum e até mesmo não te ajudaria em nada, pois você iria fazer o exercício na base do copia/cola e aí não aprenderia nada! Isso posso garantir

Procure dar uma olhada no tutorial q te passei e verá que não é algo tão difícil assim 

Foi preciso mudar, claro, na função para inserir um cadastro e principalmente na função para excluir um cadastro

Também foi preciso incluir uma função para buscar um cadastro

Já na função para imprimir os cadastros, como não é necessário trabalhar com os dois ponteiros de cada elemento (anterior e próximo), permaneceu como estava

Também na função para alterar um cadastro e ordenar os cadastros não foi preciso mudar, pelo mesmo princípio que mencionei com respeito a função de imprimir os cadastros

Obs: Agora fica a seu critério seguir ou não a dica que dei de consultar o material que te passei

Boa sorte!

Qualquer dúvida é só perguntar! 

[Visitante]

@Engenharia2020 Olá. Segue mais um material que encontrei e achei interessante com relação a lista duplamente encadeada:

http://www.lncc.br/~rogerio/ed/13 - Listas Duplamente Encadeadas.pdf

Se refere ao C++, mas creio que não vai ter dificuldade em entender

Abraço!