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

[Brazuca2013 0]

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

[LNW 521]

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

[Brazuca2013 0]

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.

[Brazuca2013 0]

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.

[LNW 521]

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 30 de março de 2013 por LNW
info complementar.