Listas Enlazadas — Método contiene

🔍 Implementemos el método contiene()

El método contiene() es muy sencillo.
Su objetivo es verificar si un valor existe o no dentro de la lista.

public boolean contiene(int item) {
    // Paso 1: recorrer la lista y verificar si existe
}

📊 Visualización — Lista actual

10

➡️

20

➡️

30

➡️ null

primero → 🟨10
    último → 🟩30

Buscaremos si la lista contiene(10) y luego contiene(40).

✅ Paso 1 — contiene(10)

10

➡️

20

➡️

30

➡️ null

🔍 Buscando valor: 10
    ✅ Coincidencia encontrada.

El método devuelve true ✔️

❌ Paso 2 — contiene(40)

10

➡️

20

➡️

30

➡️ null

🔍 Buscando valor: 40
    ❌ No se encontró el valor.
Se devuelve false.

🧩 Resultado final

lista.contiene(10);  ➜  true
lista.contiene(40);  ➜  false

✅ 10 sí existe en la lista. ❌ 40 no existe.

🧠 Idea principal

Pero… 🧩 ya escribimos esa lógica en indiceDe().

public boolean indiceDe(int item) {
    var actual = primero;

    while (actual != null) {
        if (actual.value == item)
            return true;
        actual = actual.next;
    }
    return false;
}

♻️ Reutilicemos indiceDe()

No necesitamos duplicar el código. Podemos reutilizar nuestro método indiceDe().

public boolean contiene(int item) {
    return indiceDe(item) != -1;
}

✔️ Si indiceDe(item) devuelve cualquier número distinto de -1, significa que el valor existe en la lista.

🧩 Ejemplo en acción

public class Main {
    public static void main(String[] args) {
        var list = new ListaEnlazada();
        list.agregarAlFinal(10);
        list.agregarAlFinal(20);
        list.agregarAlFinal(30);
        System.out.println(list.indiceDe(30));
        System.out.println(list.contiene(10)); // true
        System.out.println(list.contiene(40)); // false
    }
}

Así vamos:

public class ListaEnlazada {

    private class Nodo {
        private int value;
        private Nodo next;

        public Nodo(int value) {
            this.value = value;
        }
    }

    private Nodo primero;
    private Nodo ultimo;


    public void agregarAlInicio(int item) {
            var nodo = new Nodo(item);

            if (estaVacia()) {
               primero = ultimo = nodo;
            } else {
              nodo.next = primero;
              primero = nodo;
             }
    }

    private boolean estaVacia() {
        return primero == null;
    }

    public void agregarAlFinal(int item) {
        var nodo = new Nodo(item);

        if (primero == null) {
            primero = ultimo = nodo;
        } else {
            ultimo.next = nodo;
            ultimo = nodo;
        }
    }

    public int indiceDe(int item) {
        var actual = primero;
        int indice = 0;

        while (actual != null) {
            if (actual.value == item)
                return indice;

            actual = actual.next;
            indice++;
        }
        return -1;
    }

    public boolean contiene(int item) {
        return indiceDe(item) != -1;
    }

}