C Lista Ligada - Adicionar e Excluir

[Pedrockz]

O objetivo é adicionar valores a uma lista ligada, e também realizar a exclusão de algum valor dentro dela de acordo com o usuário.

O erro, está ocorrendo na exclusão do primeiro valor, o programa simplesmente apresenta problemas quando tento retirar o primeiro valor adicionado á lista. Mesmo ele sendo o único no nó, ou  estando em conjunto com outros valores.

OBS: Todas outras funções estão funcionando perfeitamente.

#include <stdio.h>

struct no
{
    int dado;
    struct no *proximo;
};

struct no *inicio;
struct no *novo;
struct no *aux;
struct no *anterior;

void inicializar();
void finalizar();
void finalizar_elemento(struct no *elemento);
void adicionar_no(int dado);
void adicionar_no_final();
void adicionar_no_inicio();
void adicionar_no_meio();
void excluir_no(int dado);
void excluir_no_inicio();
void excluir_no_final();
void excluir_no_meio();
void listar();
struct no *novo_no(int dado);
void menu();

int opcao = 0;
int numero = 0;

int main()
{
    inicializar();
    while(opcao != 4)
    {
        menu();
        switch(opcao)
        {
            case 1:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                adicionar_no(numero);
                break;
            case 2:
                printf("Digite um numero: ");
                scanf("%d", &numero);
                excluir_no(numero);
                break;
            case 3:
                listar();
                break;
        }
    }

    finalizar();
}

void menu()
{
    printf("Menu\n");
    printf("1 - inserir\n");
    printf("2 - excluir\n");
    printf("3 - listar\n");
    printf("4 - sair\n");

    printf("Digite sua opcao: ");
    scanf("%d", &opcao);
}

void inicializar()
{
    inicio = 0;
}

struct no * novo_no(int dado)
{
    struct no *n;
    n = malloc(sizeof(struct no));
    if(!n)
    {
        printf("Nao consegui alocar memoria!\n");
        exit(-1);
    }

    n->proximo = 0;
    n->dado = dado;

    return n;
}

void adicionar_no(int dado)
{

    novo = novo_no(dado);

    if(inicio == 0){
        inicio = novo;          // INSERÇÃO COM LISTA VAZIA
    }
    else{
        if(inicio->dado >= novo->dado){
            adicionar_no_inicio();                      // INSERÇÃO NO INICIO
        }
        else{
            aux = inicio;
            anterior = inicio;
            while(aux->proximo != 0
              && aux->dado < novo->dado){
                anterior = aux;
                aux = aux->proximo;
            }
            if(novo->dado > aux->dado){
            adicionar_no_final();
            }
            else{
            adicionar_no_meio();
            }
            }
        }

}

void adicionar_no_final()
{
    aux->proximo = novo;
}

void adicionar_no_inicio()
{
    novo->proximo = inicio;
    inicio = novo;
}

void adicionar_no_meio()
{
    novo->proximo = aux;
    anterior->proximo = novo;
}

void excluir_no(int dado)
{
    if(inicio->dado == dado){
        excluir_no_inicio();
    }
    inicio = inicio->proximo;
    aux = inicio;
    free(aux);
    anterior = inicio;
    aux = inicio;
        while(aux->proximo != 0
            && aux->dado != dado){
            anterior = aux;
            aux = aux->proximo;
            }
        if(aux->proximo == 0){
            excluir_no_final();
        }
        else{
            excluir_no_meio();
        }
    }


void excluir_no_final()
{
    anterior->proximo = 0;
    free(aux);
}

void excluir_no_inicio()
{
    aux = inicio;
    inicio = inicio->proximo;
    free(aux);
}

void excluir_no_meio()
{
    int *proximo;
    proximo = aux->proximo;
    anterior->proximo = proximo;
    free(aux);
}

void listar()
{
    if(inicio != 0)
    {
        aux = inicio;
        while(aux->proximo != 0)
        {
            printf("%d -> ", aux->dado);
            aux = aux->proximo;
        }
        printf("%d\n", aux->dado);
    }
    else
        printf("Lista vazia!\n");
}

void finalizar()
{
    if(inicio != 0)
    {
        finalizar_elemento(inicio);
        inicio = 0;
    }
}

void finalizar_elemento(struct no *elemento)
{
    if(elemento->proximo != 0)
        finalizar_elemento(elemento->proximo);
    free(elemento);
}

 

[arfneto]

struct no
{
    int dado;
    struct no *proximo;
};

 

Uma lista não é um nó. Um nó não é uma lista. Escrevendo assim só vai ter mais trabalho. MUITO mais trabalho.

 

Você esta usando funções que retornam void() e não tem argumentos. É uma ideia ruim. Cada função dessas é um buraco negro.

Nada entra e nada sai. Só usam valores globais e isso é um desastre. Se funcionar. E quando funcionar. E vai demorar.

 

Use argumentos. Retorne valores.

 

Sobre a lista

 

é mais fácil usar dois ponteiros. Tudo fica mais difícil quando os nós só tem ponteiros para um lado. Como você já deve ter descoberto toda hora tem que voltar pro início e se reposicionar.

 

É conveniente manter na lista o tamanho e um ponteiro para o inicio e para o fim. É o simples.