Lista ligada - adicionar

Aprenda a adicionar elementos em uma lista ligada

Adicionar elementos em uma lista ligada é um processo simples, pois por padrão o novo elemento será sempre adicionado ao final da lista.

Mais adiante será demonstrado como adicionar novos elementos na posição x da lista.

Pelo fato de adicionarmos sempre no final da lista, o processo para isso consiste em criar um novo nó (node) com o valor desejado, seguido pela iteração na lista até encontrar o último nó da lista, nó este onde a referência para o próximo elemento é null.

Uma vez encontrado o último nó da lista, basta adicionar a este nó a referência do novo nó, e assim ele passará a fazer parte da lista ligada.

Veja no código a seguir como fica esta implementação do método isoladamente:

public void adicionar(T valor) {
    Node<T> novoNode = new Node<>(valor);
    // caso lista vazia, define nó como início
    if (inicio == null) { 
        inicio = novoNode;
    } else {
        // caso existam elementos na lista,
        // encontra o nó final da lista e adiciona
        // o novo nó a ela
        Node<T> node = inicio;
        while (node.getProximo() != null) {
            node = node.getProximo();
        }
        node.setProximo(novoNode);
    }
}

Veja agora o método integrado na classe de lista ligada criada previamente:

public class ListaLigada<T> {

    private Node<T> inicio;

    public ListaLigada() {
        inicio = null;
    }

    public Node getInicio() {
        return inicio;
    }

    public void adicionar(T valor) {
        Node<T> novoNode = new Node<>(valor);
        if (inicio == null) {
            inicio = novoNode;
        } else {
            Node<T> node = inicio;
            while (node.getProximo() != null) {
                node = node.getProximo();
            }
            node.setProximo(novoNode);
        }
    }

}

public class Node<T> {
    private final T valor;
    private Node proximo;

    public Node(T valor) {
        this.valor = valor;
    }

    public T getValor() {
        return valor;
    }

    public Node<T> getProximo() {
        return proximo;
    }

    public void setProximo(Node<T> node) {
        proximo = node;
    }

}

Conforme demonstrado no código, adicionar elementos em uma lista ligada é uma tarefa bem mais efetiva do que adicionar em listas nativas, pois aqui somente definimos uma referência para o nó e não precisamos mover os elementos como ocorreria em uma lista nativa.

Repare ainda que apesar da boa performance, ainda temos a necessidade de percorrer a lista até encontrar o nó final da lista, algo que podemos otimizar caso tenhamos acesso a este último nó diretamente, que é justamente o que veremos mais adiante no estudo da lista ligada com cauda (tail).

Portanto, caso o seu algoritmo necessite adicionar diversos valores a uma lista, a lista ligada seria uma melhor opção sob o uso de uma lista nativa (array).