Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
Brazuca2013

Não acho o erro nesse código de Listas simples

Recommended Posts

Boa tarde pessoal!

Estou analisando esse código desde ontem e não acho porque não está excluindo o primeiro nó da lista. Eu consigo excluir os do meio, mas o primeiro não.

Agradeço quem puder me ajudar.


#include <stdio.h>
#include <stdlib.h>
#include <locale.h> /* Biblioteca necessária para uso de configurações regionais. */

struct lista {
struct lista* prox; // Um ponteiro para o próximo elemento da lista.
int info; // Um campo do tipo da informação que vamos armazenar
};
typedef struct lista Lista;

// PROTOTIPAÇÃO
int leiaInfo();
Lista* criaLista();
bool listaVazia(Lista *aLista);
Lista* adicionaNoInicio(Lista *aLista, int dado);
int exclusaoDoInicio(Lista *aLista);
int exclusaoPosicao( Lista *aLista, int posicao );
int exclusao(Lista *aLista, int dado);
void escrevaMenu();
void percorrer(Lista* aLista); //mostra todos elementos da lista
int pesquisar(Lista* aLista, int dado);
int alteracao(Lista *aLista,int dado);

// DEFINIÇÃO
#define SUCESSO 0
#define ERROLISTACHEIA 1
#define ERROLISTAVAZIA 2
#define ERROPOSICAOINEXISTENTE -1
#define ERROVALORINEXISTENTE -2

/* ####################### FUNÇÃO QUE LÊ UM NÚMERO ############################## */
int leiaInfo(){
int num;
printf("Digite um número: \n");
scanf("%d",&num);
return num;
}

/* ############################################################################## */

/* ####################### FUNÇÃO QUE CRIA UMA LISTA ############################## */
Lista* criaLista(){
//Retorna ponteiro para uma nova lista ou NULO
Lista *aLista;

aLista = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço
// testa se conseguiu alocar a lista
if (aLista != NULL) {
aLista = NULL;
}
return(aLista);
}

/* ################################################################################ */

/* #################### FUNÇÃO QUE TESTA SE LISTA ESTÁ VAZIA ###################### */

bool listaVazia(Lista *aLista)
{
if (aLista == NULL)
return(true);
else
return(false);
}

/* ############################################################################## */


/* #################### FUNÇÃO QUE ADICIONA NO INÍCIO ########################## */
Lista* adicionaNoInicio(Lista *aLista, int dado){
// aLista: é a lista atual de dados
// dado: é o novo dado a ser inserido
// novo: variável auxiliar do novo elemento
Lista *novo;

novo = aLista;
novo = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço

if (novo == NULL){
printf("cheia");
//return(ERROLISTACHEIA); // retorna caso não haja mais espaço para armazenar o valor
}else{
novo->prox = aLista; // o primeiro item da lista é referenciado como o próximo do novo, ou seja, o segundo item
novo->info = dado; // recebe o dado passado como parâmetro
aLista = novo; // o primeiro item da lista recebe o novo valor
return(aLista);
}
}
/* ############################################################################## */


/* #################### FUNÇÃO QUE EXCLUI NA POSIÇÃO ########################## */
int exclusaoPosicao( Lista *aLista, int posicao )
{
Lista *anterior, *eliminar;
int volta, aux=0;
if (posicao == 0){
return(exclusaoDoInicio(aLista));
}else{
anterior = aLista;
while(aux<=posicao-2)
{
anterior = anterior->prox;
aux++;
}
eliminar = anterior->prox;
volta = eliminar->info;
anterior->prox = eliminar->prox;
free(eliminar);
return(volta);
}
}
/* ############################################################################## */

/* #################### FUNÇÃO QUE EXCLUI DO INÍCIO ########################## */
int exclusaoDoInicio( Lista *aLista )
{
Lista *saiu = NULL;
int volta;

if (listaVazia(aLista)){
return(ERROLISTAVAZIA);
}else{
saiu = aLista;
volta = saiu->info;
aLista = saiu->prox;
free(saiu);
//percorrer(aLista);
return(volta);
}
}
/* ############################################################################## */

/* #################### FUNÇÃO DE EXCLUSÃO ########################## */
int exclusao(Lista *aLista, int dado)
{
int posicao; //Variável auxiliar para a posicao

if(listaVazia(aLista)){
return(ERROLISTAVAZIA);
}else{
posicao = pesquisar(aLista, dado);
if (posicao != -2){
exclusaoPosicao(aLista, posicao);
}
return(ERROVALORINEXISTENTE);
}
}
/* ############################################################################## */

/* #################### FUNÇÃO QUE ESCREVE O MENU ########################## */
void escrevaMenu(){

printf("\n\n>>>>>>>>>>>>>>>>>>> MENU PRINCIPAL <<<<<<<<<<<<<<<<<<<<<\n");
printf(" Digite 1 para Inserir um elemento no início da lista\n");
printf(" Digite 2 para Alterar um elemento na lista\n");
printf(" Digite 3 para Excluir um elemento na lista\n");
printf(" Digite 4 para Excluir o primeiro elemento da lista\n");
printf(" Digite 5 para Percorrer a lista\n");
printf(" Digite 6 para Pesquisar um elemento na lista\n");
printf(" Digite 7 para Sair\n\n");

}
/* ############################################################################## */

/* #################### FUNÇÃO QUE PERCORRE A LISTA ########################## */
void percorrer(Lista* aLista) //mostra todos elementos da lista
{
Lista* aux; //cria lista auxiliar
if (listaVazia(aLista)){ //verifica se a lista está vazia
//return(ERROLISTAVAZIA);
printf("Lista Vazia\n");
}

for(aux = aLista; aux != NULL; aux = aux->prox){
printf("%d,",aux->info); //imprime elemento da lista
}
}
/* ############################################################################## */


/* #################### FUNÇÃO QUE PESQUISA A LISTA ########################## */
int pesquisar(Lista* aLista, int dado)
{
Lista* aux; //cria lista auxiliar
int pos = 0;

if(listaVazia(aLista)){ //verifica se a lista está vazia
return(ERROLISTAVAZIA);
}
for(aux = aLista; aux != NULL; aux = aux->prox){
if(dado == aux->info){ //comparação dos elementos
printf("Encontrado número %d\n",dado);
return(pos); // interrompe a execução
}
pos++;
}
printf("Não foi possível achar o número!");
return(ERROVALORINEXISTENTE);
}
/* ############################################################################## */


/* #################### FUNÇÃO QUE ALTERA O NÚMERO ########################## */
// aLista: é a lista atual de dados
// dado: é o novo dado a ser inserido
// novo: variável auxiliar do novo elemento
// Tipo: é o tipo do dado. Ex.: inteiro, real, literal, logico

int alteracao(Lista *aLista, int dado)
{
Lista *alterar;
int novo;

if (listaVazia(aLista)){
return(ERROLISTAVAZIA); // retorna caso não haja mais espaço para armazenar o valor
}

for(alterar = aLista; alterar != NULL; alterar = alterar->prox){
if (dado == alterar->info){
printf("Encontrado!\n");
printf("Digite o novo valor!\n");
scanf("%d",&novo);
alterar->info = novo;
return(SUCESSO);
}
}
printf("Não foi possível achar o número!");

}
/* ############################################################################## */




main(){
setlocale(LC_ALL,""); /* Função que faz a mágica acontecer. Isso funciona do DevC++ ? */
Lista *ListaNumeros;
int opcao, erro, dado;

ListaNumeros = criaLista();
opcao = 0;
while (opcao != 7){
escrevaMenu();
printf("Digite uma opção: ");
scanf("%d",&opcao);
switch (opcao){
case 1:
// chama o processo de adição no início da lista
dado = leiaInfo();
ListaNumeros = adicionaNoInicio(ListaNumeros,dado);
break;
case 2:
// chama o processo de alteração de um número na lista
dado = leiaInfo(); // lendo o número a ser alterado
alteracao(ListaNumeros,dado);
break;
case 3:
// chama o processo de exclusão de um número na lista
dado = leiaInfo(); // lendo o número a ser excluído
erro = exclusao(ListaNumeros,dado);
break;
case 4:
// chama o processo de exclusão do primeiro número da lista
erro = exclusaoDoInicio(ListaNumeros);
break;
case 5:
// chama o processo para percorrer a lista
percorrer(ListaNumeros);
break;
case 6:
// chama o processo para pesquisar um número na lista
dado = leiaInfo(); // lendo o número a ser pesquisado
pesquisar(ListaNumeros,dado);
break;
case 7:
// saindo do sistema
printf("Obrigado por utilizar o sistema. Até a próxima!");
break;
default:
printf("Opção inválida!");
}
}
}

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá,

Bem-vindo! ;)

Para evitar de postar todo o código, vou colocar as modificações (algumas em negrito):

// PROTOTIPAÇÃO
(...)
[B]int exclusaoDoInicio(Lista **aLista);[/B]

/* #################### FUNÇÃO QUE EXCLUI NA POSIÇÃO ########################## */
int exclusaoPosicao( Lista *aLista, int posicao )
{
Lista *anterior, *eliminar;
int volta, aux=0;
if (posicao == 0)
{
[B]return(exclusaoDoInicio(&aLista));[/B]
}
else
(...)

/* #################### FUNÇÃO QUE EXCLUI DO INÍCIO ########################## */
int exclusaoDoInicio( Lista **aLista )
{
Lista *head, *p;

if (listaVazia(*aLista))
{
return(ERROLISTAVAZIA);
}
else
{
p = *aLista;
head = p->prox;
*aLista = head;
free(p);
return(SUCESSO);
}
}
/* ############################################################################## */

        case 4:
// chama o processo de exclusão do primeiro número da lista
[B]erro = exclusaoDoInicio(&ListaNumeros);[/B]
break;

Não verifiquei muito as outras funções.

Seria bom estabelecer um padrão para o seu programa. Por exemplo, decidir se todas as funções vão retornar algum código de erro ou se vão retornar o ponteiro para a lista.. no caso acima, eu mantive o retorno original.

Teste aí, ;)

NW

Compartilhar este post


Link para o post
Compartilhar em outros sites
  • Autor do tópico
  • Valeu LNW, funcionou perfeitamente.

    Mas quero aprender e faço algumas perguntas:

    - Por que o excluir do meio da lista estava funcionando perfeitamente e o excluir no início não.

    - O que representa essas adaptações que vocês fez para funcionar o código?

    Agradeço se me ajudar a aprender!

    Abraço.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites
  • Autor do tópico
  • Olá LNW, achei que tivesse resolvido tudo, mas ainda não. Fiz as alterações que me pediu.

    Uma parte funcionou corretamente, mas ainda existe outro problema:

    - Passo 01: cadastrei os números 10, 20 e 30 na lista através do menu 1;

    - Passo 02: Acessei o ITEM 3 do menu e tentei apagar o número 30, que seria o primeiro da lista.

    - Passo 03: Acessei o ITEM 5 do menu para listar os valores e pimba: O número 30 não foi excluído. O pior é que eu consigo apagar os números sequencias, menos o primeiro.

    Segue o código atualizado:


    #include <stdio.h>
    #include <stdlib.h>
    #include <locale.h> /* Biblioteca necessária para uso de configurações regionais. */

    struct lista {
    struct lista* prox; // Um ponteiro para o próximo elemento da lista.
    int info; // Um campo do tipo da informação que vamos armazenar
    };
    typedef struct lista Lista;

    // PROTOTIPAÇÃO
    int leiaInfo();
    Lista* criaLista();
    bool listaVazia(Lista *aLista);
    Lista* adicionaNoInicio(Lista *aLista, int dado);
    int exclusaoDoInicio(Lista **aLista);
    int exclusaoPosicao( Lista *aLista, int posicao );
    int exclusao(Lista *aLista, int dado);
    void escrevaMenu();
    void percorrer(Lista* aLista); //mostra todos elementos da lista
    int pesquisar(Lista* aLista, int dado);
    int alteracao(Lista *aLista,int dado);

    // DEFINIÇÃO
    #define SUCESSO 0
    #define ERROLISTACHEIA 1
    #define ERROLISTAVAZIA 2
    #define ERROPOSICAOINEXISTENTE -1
    #define ERROVALORINEXISTENTE -2

    /* ####################### FUNÇÃO QUE LÊ UM NÚMERO ############################## */
    int leiaInfo(){
    int num;
    printf("Digite um número: \n");
    scanf("%d",&num);
    return num;
    }

    /* ############################################################################## */

    /* ####################### FUNÇÃO QUE CRIA UMA LISTA ############################## */
    Lista* criaLista(){
    //Retorna ponteiro para uma nova lista ou NULO
    Lista *aLista;

    aLista = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço
    // testa se conseguiu alocar a lista
    if (aLista != NULL) {
    aLista = NULL;
    }
    return(aLista);
    }

    /* ################################################################################ */

    /* #################### FUNÇÃO QUE TESTA SE LISTA ESTÁ VAZIA ###################### */

    bool listaVazia(Lista *aLista)
    {
    if (aLista == NULL)
    return(true);
    else
    return(false);
    }

    /* ############################################################################## */


    /* #################### FUNÇÃO QUE ADICIONA NO INÍCIO ########################## */
    Lista* adicionaNoInicio(Lista *aLista, int dado){
    // aLista: é a lista atual de dados
    // dado: é o novo dado a ser inserido
    // novo: variável auxiliar do novo elemento
    Lista *novo;

    novo = aLista;
    novo = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço

    if (novo == NULL){
    printf("cheia");
    //return(ERROLISTACHEIA); // retorna caso não haja mais espaço para armazenar o valor
    }else{
    novo->prox = aLista; // o primeiro item da lista é referenciado como o próximo do novo, ou seja, o segundo item
    novo->info = dado; // recebe o dado passado como parâmetro
    aLista = novo; // o primeiro item da lista recebe o novo valor
    return(aLista);
    }
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE EXCLUI NA POSIÇÃO ########################## */
    int exclusaoPosicao( Lista *aLista, int posicao )
    {
    Lista *anterior, *eliminar;
    int volta, aux=0;
    if (posicao == 0){
    return(exclusaoDoInicio(&aLista));
    }else{
    anterior = aLista;
    while(aux<=posicao-2)
    {
    anterior = anterior->prox;
    aux++;
    }
    eliminar = anterior->prox;
    volta = eliminar->info;
    anterior->prox = eliminar->prox;
    free(eliminar);
    return(volta);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE EXCLUI DO INÍCIO ########################## */
    int exclusaoDoInicio( Lista **aLista )
    {
    Lista *head, *p;

    if (listaVazia(*aLista))
    {
    return(ERROLISTAVAZIA);
    }
    else
    {
    p = *aLista;
    head = p->prox;
    *aLista = head;
    free(p);
    return(SUCESSO);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO DE EXCLUSÃO ########################## */
    int exclusao(Lista *aLista, int dado)
    {
    int posicao; //Variável auxiliar para a posicao

    if(listaVazia(aLista)){
    return(ERROLISTAVAZIA);
    }else{
    posicao = pesquisar(aLista, dado);
    if (posicao != -2){
    exclusaoPosicao(aLista, posicao);
    }
    return(ERROVALORINEXISTENTE);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE ESCREVE O MENU ########################## */
    void escrevaMenu(){

    printf("\n\n>>>>>>>>>>>>>>>>>>> MENU PRINCIPAL <<<<<<<<<<<<<<<<<<<<<\n");
    printf(" Digite 1 para Inserir um elemento no início da lista\n");
    printf(" Digite 2 para Alterar um elemento na lista\n");
    printf(" Digite 3 para Excluir um elemento na lista\n");
    printf(" Digite 4 para Excluir o primeiro elemento da lista\n");
    printf(" Digite 5 para Percorrer a lista\n");
    printf(" Digite 6 para Pesquisar um elemento na lista\n");
    printf(" Digite 7 para Sair\n\n");

    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE PERCORRE A LISTA ########################## */
    void percorrer(Lista* aLista) //mostra todos elementos da lista
    {
    Lista* aux; //cria lista auxiliar
    if (listaVazia(aLista)){ //verifica se a lista está vazia
    //return(ERROLISTAVAZIA);
    printf("Lista Vazia\n");
    }

    for(aux = aLista; aux != NULL; aux = aux->prox){
    printf("%d,",aux->info); //imprime elemento da lista
    }
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE PESQUISA A LISTA ########################## */
    int pesquisar(Lista* aLista, int dado)
    {
    Lista* aux; //cria lista auxiliar
    int pos = 0;

    if(listaVazia(aLista)){ //verifica se a lista está vazia
    return(ERROLISTAVAZIA);
    }
    for(aux = aLista; aux != NULL; aux = aux->prox){
    if(dado == aux->info){ //comparação dos elementos
    printf("Encontrado número %d\n",dado);
    return(pos); // interrompe a execução
    }
    pos++;
    }
    printf("Não foi possível achar o número!");
    return(ERROVALORINEXISTENTE);
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE ALTERA O NÚMERO ########################## */
    // aLista: é a lista atual de dados
    // dado: é o novo dado a ser inserido
    // novo: variável auxiliar do novo elemento
    // Tipo: é o tipo do dado. Ex.: inteiro, real, literal, logico

    int alteracao(Lista *aLista, int dado)
    {
    Lista *alterar;
    int novo;

    if (listaVazia(aLista)){
    return(ERROLISTAVAZIA); // retorna caso não haja mais espaço para armazenar o valor
    }

    for(alterar = aLista; alterar != NULL; alterar = alterar->prox){
    if (dado == alterar->info){
    printf("Encontrado!\n");
    printf("Digite o novo valor!\n");
    scanf("%d",&novo);
    alterar->info = novo;
    return(SUCESSO);
    }
    }
    printf("Não foi possível achar o número!");

    }
    /* ############################################################################## */




    main(){
    setlocale(LC_ALL,""); /* Função que faz a mágica acontecer. Isso funciona do DevC++ ? */
    Lista *ListaNumeros;
    int opcao, erro, dado;

    ListaNumeros = criaLista();
    opcao = 0;
    while (opcao != 7){
    escrevaMenu();
    printf("Digite uma opção: ");
    scanf("%d",&opcao);
    switch (opcao){
    case 1:
    // chama o processo de adição no início da lista
    dado = leiaInfo();
    ListaNumeros = adicionaNoInicio(ListaNumeros,dado);
    break;
    case 2:
    // chama o processo de alteração de um número na lista
    dado = leiaInfo(); // lendo o número a ser alterado
    alteracao(ListaNumeros,dado);
    break;
    case 3:
    // chama o processo de exclusão de um número na lista
    dado = leiaInfo(); // lendo o número a ser excluído
    erro = exclusao(ListaNumeros,dado);
    break;
    case 4:
    // chama o processo de exclusão do primeiro número da lista
    erro = exclusaoDoInicio(&ListaNumeros);
    break;
    case 5:
    // chama o processo para percorrer a lista
    percorrer(ListaNumeros);
    break;
    case 6:
    // chama o processo para pesquisar um número na lista
    dado = leiaInfo(); // lendo o número a ser pesquisado
    pesquisar(ListaNumeros,dado);
    break;
    case 7:
    // saindo do sistema
    printf("Obrigado por utilizar o sistema. Até a próxima!");
    break;
    default:
    printf("Opção inválida!");
    }
    }
    }

    Agradeço a ajuda.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Brazuca2013,

    Olá LNW, achei que tivesse resolvido tudo, mas ainda não. Fiz as alterações que me pediu.

    Uma parte funcionou corretamente, mas ainda existe outro problema:

    - Passo 01: cadastrei os números 10, 20 e 30 na lista através do menu 1;

    - Passo 02: Acessei o ITEM 3 do menu e tentei apagar o número 30, que seria o primeiro da lista.

    - Passo 03: Acessei o ITEM 5 do menu para listar os valores e pimba: O número 30 não foi excluído. O pior é que eu consigo apagar os números sequencias, menos o primeiro.

    Segue o código atualizado:

    Agradeço a ajuda.

    Desculpe pela demora.. tive uns problemas pessoais por aqui.

    Olha, o problema é o mesmo do seu primeiro código. Ao excluir o primeiro nó da lista, você precisa atualizar o ponteiro que passará a apontar para o agora primeiro nó da lista (que antes era o segundo). O mesmo problema. O que ocorre é que você (ou quem escreveu) talvez tenha esquecido desse detalhe e apenas trabalhou esse ponteiro corretamente na função que cria a lista (e também na de adicionar no início)). Ali, sim, ela retorna um ponteiro já para o primeiro nó alocado. E se esse nó for removido, esse ponteiro também precisa ser atualizado. O que eu novamente fiz no seu código abaixo foi trabalhar com a passagem do ponteiro por referência para evitar mudanças radicais... Lembre-se que você não está trabalhando com um ponteiro global, estando visível em todo o programa.

    Espero que ajude. Qualquer dúvida é só perguntar.


    #include <stdlib.h>
    #include <stdbool.h>
    #include <locale.h> /* Biblioteca necessária para uso de configurações regionais. */

    struct lista
    {
    struct lista* prox; // Um ponteiro para o próximo elemento da lista.
    int info; // Um campo do tipo da informação que vamos armazenar
    };
    typedef struct lista Lista;

    // PROTOTIPAÇÃO
    int leiaInfo();
    Lista* criaLista();
    bool listaVazia(Lista *aLista);
    Lista* adicionaNoInicio(Lista *aLista, int dado);
    int exclusaoDoInicio(Lista **aLista);
    int exclusaoPosicao( Lista **aLista, int posicao );
    int exclusao(Lista **aLista, int dado);
    void escrevaMenu();
    void percorrer(Lista* aLista); //mostra todos elementos da lista
    int pesquisar(Lista* aLista, int dado);
    int alteracao(Lista *aLista,int dado);

    // DEFINIÇÃO
    #define SUCESSO 0
    #define ERROLISTACHEIA 1
    #define ERROLISTAVAZIA 2
    #define ERROPOSICAOINEXISTENTE -1
    #define ERROVALORINEXISTENTE -2

    /* ####################### FUNÇÃO QUE LÊ UM NÚMERO ############################## */
    int leiaInfo()
    {
    int num;
    printf("Digite um número: \n");
    scanf("%d",&num);
    return num;
    }

    /* ############################################################################## */

    /* ####################### FUNÇÃO QUE CRIA UMA LISTA ############################## */
    Lista* criaLista()
    {
    //Retorna ponteiro para uma nova lista ou NULO
    Lista *aLista;

    aLista = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço
    // testa se conseguiu alocar a lista
    if (aLista != NULL)
    {
    aLista = NULL;
    }
    return(aLista);
    }

    /* ################################################################################ */

    /* #################### FUNÇÃO QUE TESTA SE LISTA ESTÁ VAZIA ###################### */

    bool listaVazia(Lista *aLista)
    {
    if (aLista == NULL)
    return(true);
    else
    return(false);
    }

    /* ############################################################################## */


    /* #################### FUNÇÃO QUE ADICIONA NO INÍCIO ########################## */
    Lista* adicionaNoInicio(Lista *aLista, int dado)
    {
    // aLista: é a lista atual de dados
    // dado: é o novo dado a ser inserido
    // novo: variável auxiliar do novo elemento
    Lista *novo;

    novo = aLista;
    novo = (Lista*) malloc(sizeof(Lista)); // alocando um novo espaço

    if (novo == NULL)
    {
    printf("cheia");
    //return(ERROLISTACHEIA); // retorna caso não haja mais espaço para armazenar o valor
    }
    else
    {
    novo->prox = aLista; // o primeiro item da lista é referenciado como o próximo do novo, ou seja, o segundo item
    novo->info = dado; // recebe o dado passado como parâmetro
    aLista = novo; // o primeiro item da lista recebe o novo valor
    return(aLista);
    }
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE EXCLUI NA POSIÇÃO ########################## */
    int exclusaoPosicao( Lista **aLista, int posicao )
    {
    Lista *anterior, *eliminar;
    int volta, aux=0;
    if (posicao == 0)
    {
    return(exclusaoDoInicio(&*aLista));
    }
    else
    {
    anterior = *aLista;
    while(aux<=posicao-2)
    {
    anterior = anterior->prox;
    aux++;
    }
    eliminar = anterior->prox;
    volta = eliminar->info;
    anterior->prox = eliminar->prox;
    free(eliminar);
    return(volta);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE EXCLUI DO INÍCIO ########################## */
    int exclusaoDoInicio( Lista **aLista )
    {
    Lista *head, *p;

    if (listaVazia(*aLista))
    {
    return(ERROLISTAVAZIA);
    }
    else
    {
    p = *aLista;
    head = p->prox;
    *aLista = head;
    free(p);
    return(SUCESSO);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO DE EXCLUSÃO ########################## */
    int exclusao(Lista **aLista, int dado)
    {
    int posicao; //Variável auxiliar para a posicao

    if(listaVazia(*aLista))
    {
    return(ERROLISTAVAZIA);
    }
    else
    {
    posicao = pesquisar(*aLista, dado);
    if (posicao != -2)
    {
    exclusaoPosicao(&*aLista, posicao);
    }
    return(ERROVALORINEXISTENTE);
    }
    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE ESCREVE O MENU ########################## */
    void escrevaMenu()
    {

    printf("\n\n>>>>>>>>>>>>>>>>>>> MENU PRINCIPAL <<<<<<<<<<<<<<<<<<<<<\n");
    printf(" Digite 1 para Inserir um elemento no início da lista\n");
    printf(" Digite 2 para Alterar um elemento na lista\n");
    printf(" Digite 3 para Excluir um elemento na lista\n");
    printf(" Digite 4 para Excluir o primeiro elemento da lista\n");
    printf(" Digite 5 para Percorrer a lista\n");
    printf(" Digite 6 para Pesquisar um elemento na lista\n");
    printf(" Digite 7 para Sair\n\n");

    }
    /* ############################################################################## */

    /* #################### FUNÇÃO QUE PERCORRE A LISTA ########################## */
    void percorrer(Lista* aLista) //mostra todos elementos da lista
    {
    Lista* aux; //cria lista auxiliar
    if (listaVazia(aLista)) //verifica se a lista está vazia
    {
    //return(ERROLISTAVAZIA);
    printf("Lista Vazia\n");
    }

    for(aux = aLista; aux != NULL; aux = aux->prox)
    {
    printf("%d,",aux->info); //imprime elemento da lista
    }
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE PESQUISA A LISTA ########################## */
    int pesquisar(Lista* aLista, int dado)
    {
    Lista* aux; //cria lista auxiliar
    int pos = 0;

    if(listaVazia(aLista)) //verifica se a lista está vazia
    {
    return(ERROLISTAVAZIA);
    }
    for(aux = aLista; aux != NULL; aux = aux->prox)
    {
    if(dado == aux->info) //comparação dos elementos
    {
    printf("Encontrado número %d\n",dado);
    return(pos); // interrompe a execução
    }
    pos++;
    }
    printf("Não foi possível achar o número!");
    return(ERROVALORINEXISTENTE);
    }
    /* ############################################################################## */


    /* #################### FUNÇÃO QUE ALTERA O NÚMERO ########################## */
    // aLista: é a lista atual de dados
    // dado: é o novo dado a ser inserido
    // novo: variável auxiliar do novo elemento
    // Tipo: é o tipo do dado. Ex.: inteiro, real, literal, logico

    int alteracao(Lista *aLista, int dado)
    {
    Lista *alterar;
    int novo;

    if (listaVazia(aLista))
    {
    return(ERROLISTAVAZIA); // retorna caso não haja mais espaço para armazenar o valor
    }

    for(alterar = aLista; alterar != NULL; alterar = alterar->prox)
    {
    if (dado == alterar->info)
    {
    printf("Encontrado!\n");
    printf("Digite o novo valor!\n");
    scanf("%d",&novo);
    alterar->info = novo;
    return(SUCESSO);
    }
    }
    printf("Não foi possível achar o número!");

    }
    /* ############################################################################## */




    int main()
    {
    setlocale(LC_ALL,""); /* Função que faz a mágica acontecer. Isso funciona do DevC++ ? */
    Lista *ListaNumeros;
    int opcao, erro, dado;

    ListaNumeros = criaLista();
    opcao = 0;
    while (opcao != 7)
    {
    escrevaMenu();
    printf("Digite uma opção: ");
    scanf("%d",&opcao);
    switch (opcao)
    {
    case 1:
    // chama o processo de adição no início da lista
    dado = leiaInfo();
    ListaNumeros = adicionaNoInicio(ListaNumeros,dado);
    break;
    case 2:
    // chama o processo de alteração de um número na lista
    dado = leiaInfo(); // lendo o número a ser alterado
    alteracao(ListaNumeros,dado);
    break;
    case 3:
    // chama o processo de exclusão de um número na lista
    dado = leiaInfo(); // lendo o número a ser excluído
    erro = exclusao(&ListaNumeros,dado);
    break;
    case 4:
    // chama o processo de exclusão do primeiro número da lista
    erro = exclusaoDoInicio(&ListaNumeros);
    break;
    case 5:
    // chama o processo para percorrer a lista
    percorrer(ListaNumeros);
    break;
    case 6:
    // chama o processo para pesquisar um número na lista
    dado = leiaInfo(); // lendo o número a ser pesquisado
    pesquisar(ListaNumeros,dado);
    break;
    case 7:
    // saindo do sistema
    printf("Obrigado por utilizar o sistema. Até a próxima!");
    break;
    default:
    printf("Opção inválida!");
    }
    }
    return 0;
    }
    #include <stdio.h>

    Um abraço,

    LNW

    Editado por LNW
    info complementar.

    Compartilhar este post


    Link para o post
    Compartilhar em outros sites

    Crie uma conta ou entre para comentar

    Você precisar ser um membro para fazer um comentário






    Sobre o Clube do Hardware

    No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

    Direitos autorais

    Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

    ×