Estruturas de dados com JAVA - Lista simplesmente encadeada

Neste post, vou iniciar um dos tópcos iniciais sobre algoritmos e estruturas de dados:
Listas simplesmente encadeadas. Dada uma estrutura de dado (pode ser uma classe ou um struct em c), podemos aninhar estes elementos de forma sequencial, onde cada elemento aponta para um próximo elemento até que o último elemento não aponte para mais nada. Neste tipo de estrutura podemos identificar um elemento como sendo o inicial (header) e o elemento final é o que aponta para nada (null).

Abaixo seguem implementações para este tópico.

Definindo a estrutura de dado de um elemento Nó:

public class Node {
    
    private String element;
    private Node next;
    
    public Node(String s, Node n) {
        setElement(s);
        setNext(n);
    }

    public String getElement() {
        return element;
    }

    public void setElement(String element) {
        this.element = element;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
    
}

Abaixo segue a implementação da lista com operações básicas para navegação, inserção e remoção:

public class SList {
    
    private Node head;
    private int size;
    
    /** Creates a new instance of SList */
    public SList() {
        head = null;
        size = 0;
    }
    
    public Node getFirst() throws IllegalArgumentException {
        if (head == null)
            throw new IllegalArgumentException("Lista Vazia");
        return head;
    }
    
    public Node getNext(Node n) throws IllegalArgumentException {
        if (size == 0)
            throw new IllegalArgumentException("Lista vazia");
        if (n.getNext() == null)
            throw new IllegalArgumentException("fim da lista");
        return n.getNext();
    }
    
    public void addFirst(Node v) {
        v.setNext(head);
        head = v;
        size++;
    }
    
    public void addLast(Node v) {
        if (head != null) {
            
            Node aux = null;
            for (aux = head; aux.getNext() != null; aux = aux.getNext() );
            v.setNext(null);
            aux.setNext(v);
            size++;
            
        } else {
            addFirst(v);
        }
    }
    
    public void removeFirst() throws IllegalArgumentException {
        if (size == 0)
            throw new IllegalArgumentException();
        
        Node aux = head;
        head = head.getNext();
        aux.setNext(null);
        size --;        
    }
}

E agora um exemplo de utilização com navagação na lista:

 public class Principal {
    
    private SList lista;
    
    public Principal() {
        lista = new SList();
        
        Node node = new Node("A", null);
        
        lista.addFirst(node);
        
        node = new Node("B", null);
        lista.addFirst(node); 
        
        node = new Node("C", null);
        lista.addFirst(node); 
    }
    
    public void printLista() {
        Node node = lista.getFirst();
        do  {
            System.out.println( "Elemento:" + node.getElement() );
            node = node.getNext();
        } while (node != null);
    }
    
    public static void main(String[] args) {
        Principal me = new Principal();
        me.printLista();
    }
    
}

veja o tópico de listas duplamente encadeadas