#estruturas_de_dados #listas_ligadas #snippets

listas_ligadas.c

/*
Algumas operações em listas ligadas podem variar para permitir a utilização de outros tipos de dados.
As prinicipais variações são nos algoritmos de Inserção e no de Remoção.

>As Inserções em Listas Ligadas podem ser, basicamente, das seguintes maneiras:
- Inserir um elemento no Final da Lista
- Inserir ume lemento no Início da Lista
- Inserir um elemento em uma Lista Ordenada

>Já a Remoção pode ser feita das formas:
- Buscar um elemento e remover da lista
- Remover o primeiro elemento
- Remover o ultimo elemento
*/


/*
>>INSERÇÃO (InsereFinal)
>Um novo nó é sempre inserido no final da Lista.
>Se a lista está vazia:
- Faz a lista apontar para um novo nó
>Senão, procura o último elemento:
- Faz o último elemento apontar para o novo nó.
*/

//Inserção (InsereFinal)
void InsereFim(lista *L, pno No){
    pno p = *L;
    if(p == NULL)
        *L = No;
    else {
        while(p->prox != NULL)
            p = p->prox;
        p->prox = No;
    }
}

//Inserção (InsereFinal - Recursivo)
void InsereFim(lista *L, pno No){
    pno p = *L;

    if(p == NULL)
        *L = No;
    else
        InsereFim(&(p->prox), No);
}

/*
>>INSERÇÃO (InsereInício)
>Um novo nó é sempre inserido no inicio da Lista
>Se a Lista está vazia:
- Faz a lista apontar para o novo nó.
>Senão:
- Faz o nó apontar para o primeiro da Lista
- Faz a Lista apontar para o novo nó
*/

//Inserção (InsereInicio)
void InsereInicio(lista *L, pno No){
    if(*L != NULL)
        No->prox = *L;
    *L = No;
}

/*
>>INSERÇÃO (InsereOrdenado)
>Insere um nó mantendo a lista ordenada
>Se a Lista está vazia:
- Faz a lista apontar para o novo nó
>Se não, encontra o primeiro nó maior ou igual ao novo nó
- Faz o nó apontar para o nó atual
- Faz o anterior apontar para o novo nó
*/

//Inserção (InsereOrdenado)
void InsereOrdenado(lista *L, pno No){
    pno a = NULL, p = *L;

    if(p==NULL)
        *L = No;
    else{
        while(p != NULL && p->info > No->info){
            a = p;
            p = p->prox;
        }
        if(a == NULL){
            No->prox = *L;
            *L = No;
        }
        else {
            No->prox = p;
            a->prox = No;
        }
    }
}

//Inserção (InsereOrd Recursivo)
void InsereOrdenado (lista *L, pno No){
    pno p = *L;
    if(p == NULL)
        *L = No;
    else if(p->info >= No->info){
        No->prox = p;
        *L = No;
    }
    else
        InsereOrdenado(&(p->prox), No);
}

/*
>>REMOÇÃO (RemoveNo)
>Remove o nó cuja informação é info.
>Se a Lista está vazia, nada a fazer.
>Se não, procura info
- Guarda o endereço do nó a ser removido
- Faz o nó anterior apontar para o próximo
- Libera a memória
*/

//Remoção (RemoveNo)
void RemoveNo(lista *L, TipoDado Info){
    pno a = NULL, p = *L;

    while (p != NULL && p->info != Info){
        a = p;
        p = p->prox;
    }
    if(p != NULL){
        if(p->info == Info){
            if(a == NULL)
                *L = p->prox;
            else
                a->prox = p->prox;
            free(p);
        }
    }
}

//Remoção (RemoveNo - Recursivo)
void RemoveNo(lista *L, TipoDado Info){
    pno p = *L;
    if(p != NULL){
        if(p->info == Info){
            *L = p->prox;
            free(p);
        }
        else RemoveNo(&(p->prox), Info);
    }
}

/*
>>REMOÇÃO (RemovePrimeiro)
>Neste caso, sempre o primeiro elemento dalista será removido
>Se a Lista está vazia, nada a fazer.
>Se não
- Guarda o endereço do primeiro nó
- Faz a lista apontar para o próximo
- Libera a memória
*/

//RemovePrimeiro
void RemovePrimeiro(lista *L){
    pno p = *L;

    if(p != NULL){
        *L = p->prox;
        free(p);
    }
}