Ir ao conteúdo

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


Brazuca2013

Posts recomendados

Postado

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!");
}
}
}

Postado

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

Postado

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.

Postado

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.

Postado

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

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades 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

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!