Ir ao conteúdo
  • Cadastre-se

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


Brazuca2013

Posts recomendados

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

Link para o comentário
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

Link para o comentário
Compartilhar em outros sites

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.

Link para o comentário
Compartilhar em outros sites

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.

Link para o comentário
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

Link para o comentário
Compartilhar em outros sites

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...