import java.util.ArrayDeque;
import java.util.Queue;

Queue<String> pendientes = new ArrayDeque<>();

pendientes.offer("Marta Ruiz");      // entra
pendientes.offer("Diego Alonso");
pendientes.offer("Nuria Vidal");

System.out.println(pendientes.peek());    // Marta Ruiz  (mira sin sacar)
System.out.println(pendientes.poll());    // Marta Ruiz  (saca)
System.out.println(pendientes.poll());    // Diego Alonso
System.out.println(pendientes.size());    // 1

Queue<Reserva> cola = new ArrayDeque<>();

// Bucle de proceso: que la cola se vacie es NORMAL, es la condicion de parada
Reserva r;
while ((r = cola.poll()) != null) {       // poll devuelve null: idiomatico y limpio
    atender(r);
}

// Consulta puntual donde vacio SERIA un error de logica
Reserva siguiente = cola.remove();        // NoSuchElementException si esta vacia

tail = (tail + 1) & (elements.length - 1);   // vuelve a 0 al pasar del final

// Como COLA (FIFO): entra por el final, sale por el principio
Deque<String> cola = new ArrayDeque<>();
cola.offerLast("Marta Ruiz");
cola.offerLast("Diego Alonso");
System.out.println(cola.pollFirst());     // Marta Ruiz

// Como PILA (LIFO): entra y sale por el mismo extremo
Deque<String> pila = new ArrayDeque<>();
pila.push("alta");
pila.push("baja");
System.out.println(pila.pop());           // baja  (la ultima que entro)

// Como DEQUE de verdad: los dos extremos
Deque<String> doble = new ArrayDeque<>();
doble.offerFirst("urgente");              // se cuela al principio
doble.offerLast("normal");                // espera su turno al final
System.out.println(doble.pollFirst());    // urgente

import java.util.PriorityQueue;
import java.util.Queue;

// Por orden natural: el MENOR sale primero
Queue<Integer> cola = new PriorityQueue<>();
cola.offer(30);
cola.offer(10);
cola.offer(20);

System.out.println(cola.poll());    // 10
System.out.println(cola.poll());    // 20
System.out.println(cola.poll());    // 30

// Los prestamos con MAS dias de retraso primero
Queue<Prestamo> avisos = new PriorityQueue<>(
    Comparator.comparingInt((Prestamo p) -> p.diasRetraso(diaActual)).reversed());

// Las reservas mas urgentes primero y, a igualdad, las mas antiguas
Queue<Reserva> reservas = new PriorityQueue<>(
    Comparator.comparingInt(Reserva::getPrioridad)
              .thenComparingInt(Reserva::getDiaSolicitud));

Queue<Integer> cola = new PriorityQueue<>();
cola.offer(30);
cola.offer(10);
cola.offer(20);
cola.offer(5);

System.out.println(cola);              // [5, 10, 20, 30] o [5, 10, 20, 30]... depende

for (int n : cola) {
    System.out.print(n + " ");         // 5 10 20 30  ... o NO
}

Queue<Integer> cola = new PriorityQueue<>();
for (int n : new int[]{ 50, 40, 30, 20, 10 }) { cola.offer(n); }

System.out.println("toString: " + cola);        // [10, 20, 40, 50, 30]  <- NO ordenado
System.out.print("iterador: ");
cola.forEach(n -> System.out.print(n + " "));   // 10 20 40 50 30
System.out.print("\npoll:     ");
while (!cola.isEmpty()) { System.out.print(cola.poll() + " "); }   // 10 20 30 40 50

while (!cola.isEmpty()) {
    Prestamo p = cola.poll();      // en orden de prioridad garantizado
    procesar(p);
}
// ...pero la cola queda vacia

Queue<Prestamo> copia = new PriorityQueue<>(cola);   // copia el monticulo
while (!copia.isEmpty()) {
    procesar(copia.poll());
}
// la cola original sigue intacta

List<Prestamo> ordenados = new ArrayList<>(cola);
ordenados.sort(cola.comparator());       // el mismo criterio de la cola

Deque<String> ultimasOperaciones = new ArrayDeque<>();

void registrar(String operacion) {
    ultimasOperaciones.offerLast(operacion);
    if (ultimasOperaciones.size() > 100) {
        ultimasOperaciones.pollFirst();      // O(1): descarta la mas antigua
    }
}

Queue<Runnable> tareas = new ArrayDeque<>();
tareas.offer(() -> System.out.println("Calcular multas"));
tareas.offer(() -> System.out.println("Enviar avisos"));
tareas.offer(() -> System.out.println("Generar informe"));

Runnable tarea;
while ((tarea = tareas.poll()) != null) {
    tarea.run();          // se ejecutan en orden de llegada
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Recomendador {

    /** Grafo: referencia -> referencias relacionadas. */
    private final Map<String, List<String>> relacionados;

    public Recomendador(Map<String, List<String>> relacionados) {
        this.relacionados = relacionados;
    }

    /**
     * Recorrido en anchura: devuelve las referencias alcanzables desde 'origen'
     * hasta 'profundidadMaxima' saltos, en orden de CERCANIA.
     */
    public List<String> recomendar(String origen, int profundidadMaxima) {
        List<String> resultado = new ArrayList<>();
        Set<String>  visitados = new HashSet<>();
        Deque<String> porVisitar = new ArrayDeque<>();
        Deque<Integer> profundidades = new ArrayDeque<>();

        porVisitar.offerLast(origen);
        profundidades.offerLast(0);
        visitados.add(origen);

        while (!porVisitar.isEmpty()) {
            String actual = porVisitar.pollFirst();          // FIFO: por niveles
            int profundidad = profundidades.pollFirst();

            if (profundidad > 0) { resultado.add(actual); }  // el origen no se recomienda
            if (profundidad >= profundidadMaxima) { continue; }

            for (String vecino : relacionados.getOrDefault(actual, List.of())) {
                if (visitados.add(vecino)) {     // add devuelve false si ya estaba (05-06)
                    porVisitar.offerLast(vecino);
                    profundidades.offerLast(profundidad + 1);
                }
            }
        }
        return resultado;
    }
}

Map<String, List<String>> grafo = Map.of(
    "978-0000000001", List.of("978-0000000002", "978-0000000003"),   // Java Efectivo
    "978-0000000002", List.of("978-0000000003", "DVD-0007"),         // Patrones
    "978-0000000003", List.of("DVD-0007"),                           // Refactorizacion
    "DVD-0007",       List.of("REV-2024-03")
);

Recomendador r = new Recomendador(grafo);
System.out.println(r.recomendar("978-0000000001", 1));   // vecinos directos
System.out.println(r.recomendar("978-0000000001", 3));   // hasta 3 saltos, por cercania

[978-0000000002, 978-0000000003]
[978-0000000002, 978-0000000003, DVD-0007, REV-2024-03]

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import com.nexussoftware.bibliotech.dominio.Empleado;
import com.nexussoftware.bibliotech.dominio.Material;
import com.nexussoftware.bibliotech.dominio.Reserva;

/**
 * Cola FIFO de reservas de UN material, sobre ArrayDeque.
 *
 * Frente a la version con LinkedList de 05-04: mismo O(1) en los extremos,
 * pero con un array circular en lugar de nodos -> menos memoria, mejor
 * localidad de cache y ninguna presion sobre el recolector.
 */
public class ColaReservas {

    private final Material material;
    private final Deque<Reserva> pendientes = new ArrayDeque<>();

    public ColaReservas(Material material) {
        this.material = material;
    }

    /** Encolar por el final: O(1) amortizado. */
    public void reservar(Empleado empleado, int dia) {
        pendientes.offerLast(new Reserva(empleado, material, dia));
    }

    /** Reserva urgente: se cuela por delante. Solo un Deque permite esto. */
    public void reservarUrgente(Empleado empleado, int dia) {
        pendientes.offerFirst(new Reserva(empleado, material, dia, 1));
    }

    /** peekFirst: null si no hay nadie. Nunca lanza excepcion. */
    public Reserva siguiente() {
        return pendientes.peekFirst();
    }

    /** pollFirst: atiende y saca. O(1). */
    public Reserva atenderSiguiente(int dia) {
        Reserva r = pendientes.pollFirst();
        if (r != null) {
            r.marcarAtendida();
            material.prestar();
        }
        return r;
    }

    /** Cancela la reserva mas reciente de un empleado, recorriendo desde el final. */
    public boolean cancelarUltimaDe(Empleado empleado) {
        Iterator<Reserva> it = pendientes.descendingIterator();
        while (it.hasNext()) {
            if (it.next().getEmpleado().equals(empleado)) {
                it.remove();
                return true;
            }
        }
        return false;
    }

    /** Caduca las reservas que llevan demasiado esperando. */
    public int caducar(int diaActual, int diasMaximos) {
        int antes = pendientes.size();
        pendientes.removeIf(r -> r.diasEnEspera(diaActual) > diasMaximos);
        return antes - pendientes.size();
    }

    /** Posicion en la cola (1 = el siguiente). 0 si no tiene reserva. */
    public int posicionDe(Empleado empleado) {
        int posicion = 1;
        for (Reserva r : pendientes) {      // un Deque NO tiene get(i): siempre for-each
            if (r.getEmpleado().equals(empleado)) { return posicion; }
            posicion++;
        }
        return 0;
    }

    public List<Reserva> listar()  { return new ArrayList<>(pendientes); }
    public int     enEspera()      { return pendientes.size(); }
    public boolean hayPendientes() { return !pendientes.isEmpty(); }
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import com.nexussoftware.bibliotech.dominio.Gravedad;
import com.nexussoftware.bibliotech.dominio.Prestamo;

/** Avisos de vencimiento atendidos por urgencia, no por orden de llegada. */
public class ColaAvisos {

    private final Queue<Prestamo> avisos;
    private final int diaActual;

    public ColaAvisos(int diaActual) {
        this.diaActual = diaActual;
        // Mas dias de retraso primero; a igualdad, el prestamo mas antiguo.
        // El desempate hace el orden DETERMINISTA: sin el, dos prestamos con
        // el mismo retraso saldrian en orden arbitrario.
        this.avisos = new PriorityQueue<>(
            Comparator.comparingInt((Prestamo p) -> diasRetraso(p)).reversed()
                      .thenComparingInt(Prestamo::getDiaPrestamo));
    }

    private int diasRetraso(Prestamo p) {
        return p.getMaterial().calcularDiasRetraso(diaActual - p.getDiaPrestamo());
    }

    /** Encola solo lo que esta realmente vencido. O(log n). */
    public void encolar(Prestamo p) {
        if (p != null && !p.estaDevuelto() && p.estaVencido(diaActual)) {
            avisos.offer(p);
        }
    }

    public void encolarTodos(List<Prestamo> prestamos) {
        for (Prestamo p : prestamos) { encolar(p); }
    }

    /** El mas urgente, sin sacarlo. O(1). */
    public Prestamo masUrgente() {
        return avisos.peek();
    }

    /**
     * Procesa TODOS los avisos en orden de urgencia.
     *
     * IMPORTANTE: hay que vaciar la cola con poll(). Recorrerla con for-each
     * o imprimir su toString() daria el orden del monticulo interno, que NO
     * es el orden de prioridad.
     */
    public int procesarTodos() {
        int procesados = 0;
        Prestamo p;
        while ((p = avisos.poll()) != null) {      // idioma del apartado 2
            int retraso = diasRetraso(p);
            Gravedad g  = p.getMaterial().clasificarGravedad(diaActual - p.getDiaPrestamo());
            System.out.printf("[%-10s] %-16s %-24s %3d dias  %6.2f EUR%n",
                    g, p.getEmpleado().getNombre(), p.getMaterial().getTitulo(),
                    retraso, p.calcularMulta(diaActual));
            procesados++;
        }
        return procesados;
    }

    /** Los N mas urgentes, SIN vaciar la cola: se trabaja sobre una copia. */
    public List<Prestamo> topUrgentes(int cuantos) {
        Queue<Prestamo> copia = new PriorityQueue<>(avisos);   // copia el monticulo
        List<Prestamo> resultado = new ArrayList<>();
        for (int i = 0; i < cuantos && !copia.isEmpty(); i++) {
            resultado.add(copia.poll());
        }
        return resultado;
    }

    public int pendientes() { return avisos.size(); }
}

Empleado marta = new Empleado("Marta Ruiz",   "EMP-001");
Empleado diego = new Empleado("Diego Alonso", "EMP-002");
Empleado nuria = new Empleado("Nuria Vidal",  "EMP-003");

Material javaEfectivo = new Libro("Java Efectivo", "Joshua Bloch", "978-0000000001", 2018);

// --- Cola de reservas (FIFO) ---
javaEfectivo.prestar();
ColaReservas reservas = new ColaReservas(javaEfectivo);
reservas.reservar(marta, 100);
reservas.reservar(diego, 101);
reservas.reservarUrgente(nuria, 102);        // se cuela por delante

System.out.println("Siguiente: " + reservas.siguiente().getEmpleado().getNombre());
System.out.println("Posicion de Marta: " + reservas.posicionDe(marta));

// --- Cola de avisos (por prioridad) ---
List<Prestamo> prestamos = List.of(
    new Prestamo(new Libro("Java Efectivo",      "Joshua Bloch",  "978-0000000001", 2018), marta, 100),
    new Prestamo(new Revista("Java Magazine",    "REV-2024-03",   42, "Mensual"),          diego, 120),
    new Prestamo(new Dvd("Refactorizacion en vivo", "DVD-0007",   95),                     nuria, 125),
    new Prestamo(new Libro("Patrones de Diseno", "Erich Gamma",   "978-0000000002", 1994), diego, 110)
);

ColaAvisos avisos = new ColaAvisos(140);
avisos.encolarTodos(prestamos);
System.out.println("\nAvisos pendientes: " + avisos.pendientes());
System.out.println("Mas urgente: " + avisos.masUrgente().getMaterial().getTitulo());
System.out.println("\n--- Procesando por urgencia ---");
avisos.procesarTodos();

Siguiente: Nuria Vidal
Posicion de Marta: 2

Avisos pendientes: 4
Mas urgente: Java Magazine

--- Procesando por urgencia ---
[GRAVE     ] Diego Alonso     Java Magazine              13 dias    1.30 EUR
[GRAVE     ] Nuria Vidal      Refactorizacion en vivo    12 dias    6.00 EUR
[GRAVE     ] Marta Ruiz       Java Efectivo              25 dias    6.25 EUR
[GRAVE     ] Diego Alonso     Patrones de Diseno         15 dias    3.75 EUR

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import com.nexussoftware.bibliotech.dominio.Empleado;

/** Sala de espera del mostrador de prestamos. */
public class SalaEspera {

    private final Deque<Empleado> cola = new ArrayDeque<>();

    /** O(1) amortizado: escribir en 'tail' e incrementarlo. */
    public void llegar(Empleado e) {
        if (e != null) { cola.offerLast(e); }
    }

    /**
     * O(1): escribir en 'head-1' y decrementarlo (el array es CIRCULAR,
     * asi que 'head' puede dar la vuelta al final del array).
     * Con un ArrayList esto seria add(0, e): O(n).
     */
    public void llegarPrioritario(Empleado e) {
        if (e != null) { cola.offerFirst(e); }
    }

    /** O(1). pollFirst devuelve null si esta vacia; removeFirst lanzaria excepcion. */
    public Empleado atender() {
        return cola.pollFirst();
    }

    /** O(1). */
    public Empleado siguiente() {
        return cola.peekFirst();
    }

    /**
     * O(n): hay que recorrer la cola buscando al empleado. Es la unica
     * operacion cara de esta clase, y es aceptable porque irse a mitad
     * de cola es excepcional.
     */
    public boolean irse(Empleado e) {
        return cola.removeFirstOccurrence(e);   // usa equals (03-09)
    }

    /** O(n). Un Deque no tiene get(i): la posicion solo se sabe recorriendo. */
    public int posicionDe(Empleado e) {
        int posicion = 1;
        for (Empleado actual : cola) {
            if (actual.equals(e)) { return posicion; }
            posicion++;
        }
        return 0;
    }

    /** O(n). descendingIterator recorre de 'tail' a 'head'. */
    public List<Empleado> ordenInverso() {
        List<Empleado> resultado = new ArrayList<>(cola.size());
        Iterator<Empleado> it = cola.descendingIterator();
        while (it.hasNext()) { resultado.add(it.next()); }
        return resultado;
    }

    /** Vacia la cola atendiendo en orden. Idioma estandar con poll. */
    public void cerrarMostrador() {
        System.out.println("--- Cerrando mostrador: " + cola.size() + " en espera ---");
        Empleado e;
        int turno = 1;
        while ((e = cola.pollFirst()) != null) {
            System.out.printf("  Turno %d: %s (%s)%n",
                              turno++, e.getNombre(), e.getIdentificador());
        }
        System.out.println("--- Mostrador cerrado ---");
    }

    public int     enEspera() { return cola.size(); }
    public boolean vacia()    { return cola.isEmpty(); }
}

Empleado marta = new Empleado("Marta Ruiz",   "EMP-001");
Empleado diego = new Empleado("Diego Alonso", "EMP-002");
Empleado nuria = new Empleado("Nuria Vidal",  "EMP-003");

SalaEspera sala = new SalaEspera();
sala.llegar(marta);
sala.llegar(diego);
sala.llegarPrioritario(nuria);          // se cuela por delante

System.out.println("Siguiente: " + sala.siguiente().getNombre());       // Nuria Vidal
System.out.println("Posicion de Marta: " + sala.posicionDe(marta));     // 2
System.out.println("Diego se va: " + sala.irse(diego));                 // true
sala.cerrarMostrador();

Siguiente: Nuria Vidal
Posicion de Marta: 2
Diego se va: true
--- Cerrando mostrador: 2 en espera ---
  Turno 1: Nuria Vidal (EMP-003)
  Turno 2: Marta Ruiz (EMP-001)
--- Mostrador cerrado ---

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;

/** Tarea de mantenimiento del catalogo. Prioridad 1 = maxima urgencia. */
record TareaMantenimiento(String descripcion, int prioridad, int diaCreacion) {
    TareaMantenimiento {
        if (descripcion == null || descripcion.isBlank()) { descripcion = "(sin descripcion)"; }
        if (prioridad < 1 || prioridad > 10) { prioridad = 5; }
        if (diaCreacion < 0) { diaCreacion = 0; }
    }
}

public class PlanificadorTareas {

    private final Queue<TareaMantenimiento> cola;

    public PlanificadorTareas() {
        // Menor numero de prioridad primero. A igualdad, la mas antigua.
        // El desempate hace el orden DETERMINISTA y ademas justo: entre dos
        // urgencias iguales, gana la que lleva mas tiempo esperando.
        this.cola = new PriorityQueue<>(
            Comparator.comparingInt(TareaMantenimiento::prioridad)
                      .thenComparingInt(TareaMantenimiento::diaCreacion));
    }

    /** O(log n): el elemento flota hacia arriba en el monticulo. */
    public void programar(TareaMantenimiento t) {
        if (t != null) { cola.offer(t); }
    }

    /** O(1): la raiz del monticulo. */
    public TareaMantenimiento siguiente() {
        return cola.peek();
    }

    /** O(log n): saca la raiz y reorganiza. */
    public TareaMantenimiento ejecutar() {
        return cola.poll();
    }

    /**
     * Las N siguientes SIN vaciar la cola original.
     * El constructor de copia de PriorityQueue duplica el monticulo.
     */
    public List<TareaMantenimiento> proximas(int cuantas) {
        Queue<TareaMantenimiento> copia = new PriorityQueue<>(cola);
        List<TareaMantenimiento> resultado = new ArrayList<>();
        for (int i = 0; i < cuantas && !copia.isEmpty(); i++) {
            resultado.add(copia.poll());
        }
        return resultado;
    }

    public int ejecutarTodas() {
        int n = 0;
        TareaMantenimiento t;
        while ((t = cola.poll()) != null) {
            System.out.printf("  [P%d] dia %3d  %s%n", t.prioridad(), t.diaCreacion(),
                              t.descripcion());
            n++;
        }
        return n;
    }

    /** Demuestra que solo poll() respeta el orden de prioridad. */
    public void demostrarIteradorNoOrdenado() {
        System.out.println("=== El iterador NO recorre en orden de prioridad ===");

        System.out.println("toString():");
        System.out.println("  " + cola);

        System.out.print("for-each:  ");
        for (TareaMantenimiento t : cola) { System.out.print("P" + t.prioridad() + " "); }
        System.out.println();

        System.out.print("forEach:   ");
        cola.forEach(t -> System.out.print("P" + t.prioridad() + " "));
        System.out.println();

        System.out.print("poll:      ");
        Queue<TareaMantenimiento> copia = new PriorityQueue<>(cola);
        TareaMantenimiento t;
        while ((t = copia.poll()) != null) { System.out.print("P" + t.prioridad() + " "); }
        System.out.println("   <- el UNICO orden garantizado");

        System.out.println("Causa: el array interno solo cumple la propiedad de monticulo");
        System.out.println("(cada nodo <= sus hijos), no un orden total.");
    }

    public int pendientes() { return cola.size(); }
}

PlanificadorTareas p = new PlanificadorTareas();
p.programar(new TareaMantenimiento("Revisar ejemplares deteriorados",  5, 100));
p.programar(new TareaMantenimiento("Reponer DVD danado",               1, 130));
p.programar(new TareaMantenimiento("Inventario anual",                 8, 90));
p.programar(new TareaMantenimiento("Actualizar ISBN erroneos",         1, 110));
p.programar(new TareaMantenimiento("Limpiar estanterias",              5, 95));

System.out.println("Siguiente: " + p.siguiente().descripcion());
System.out.println("Proximas 2: ");
p.proximas(2).forEach(t -> System.out.println("  " + t.descripcion()));
System.out.println("Pendientes tras consultar: " + p.pendientes());

p.demostrarIteradorNoOrdenado();
System.out.println("\n--- Ejecutando todas ---");
p.ejecutarTodas();

Siguiente: Actualizar ISBN erroneos
Proximas 2:
  Actualizar ISBN erroneos
  Reponer DVD danado
Pendientes tras consultar: 5

=== El iterador NO recorre en orden de prioridad ===
toString():
  [TareaMantenimiento[...prioridad=1, diaCreacion=110], ...]
for-each:  P1 P1 P8 P5 P5
forEach:   P1 P1 P8 P5 P5
poll:      P1 P1 P5 P5 P8    <- el UNICO orden garantizado
...
--- Ejecutando todas ---
  [P1] dia 110  Actualizar ISBN erroneos
  [P1] dia 130  Reponer DVD danado
  [P5] dia  95  Limpiar estanterias
  [P5] dia 100  Revisar ejemplares deteriorados
  [P8] dia  90  Inventario anual

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class RecomendadorComparado {

    private final Map<String, List<String>> relacionados;

    public RecomendadorComparado(Map<String, List<String>> relacionados) {
        this.relacionados = relacionados;
    }

    /**
     * ANCHURA (BFS): cola FIFO. Explora por NIVELES: primero todos los
     * vecinos directos, luego los vecinos de esos, etc.
     */
    public List<String> enAnchura(String origen, int profundidadMaxima) {
        return recorrer(origen, profundidadMaxima, true);
    }

    /**
     * PROFUNDIDAD (DFS): pila LIFO. Baja todo lo que puede por una rama
     * antes de volver atras. MISMO codigo, solo cambia por que extremo se saca.
     */
    public List<String> enProfundidad(String origen, int profundidadMaxima) {
        return recorrer(origen, profundidadMaxima, false);
    }

    private List<String> recorrer(String origen, int profundidadMaxima, boolean anchura) {
        List<String>   resultado    = new ArrayList<>();
        Set<String>    visitados    = new HashSet<>();
        Deque<String>  porVisitar   = new ArrayDeque<>();
        Deque<Integer> profundidades = new ArrayDeque<>();

        porVisitar.offerLast(origen);
        profundidades.offerLast(0);
        visitados.add(origen);

        while (!porVisitar.isEmpty()) {
            // LA UNICA DIFERENCIA entre BFS y DFS esta en esta linea:
            //   pollFirst -> FIFO -> anchura
            //   pollLast  -> LIFO -> profundidad
            String actual = anchura ? porVisitar.pollFirst() : porVisitar.pollLast();
            int profundidad = anchura ? profundidades.pollFirst() : profundidades.pollLast();

            if (profundidad > 0) { resultado.add(actual); }
            if (profundidad >= profundidadMaxima) { continue; }

            for (String vecino : relacionados.getOrDefault(actual, List.of())) {
                if (visitados.add(vecino)) {      // add devuelve false si ya estaba (05-06)
                    porVisitar.offerLast(vecino);
                    profundidades.offerLast(profundidad + 1);
                }
            }
        }
        return resultado;
    }

    public static void main(String[] args) {
        Map<String, List<String>> grafo = Map.of(
            "978-0000000001", List.of("978-0000000002", "DVD-0007"),
            "978-0000000002", List.of("978-0000000003"),
            "978-0000000003", List.of("REV-2024-03"),
            "DVD-0007",       List.of("REV-2024-03")
        );

        RecomendadorComparado r = new RecomendadorComparado(grafo);
        System.out.println("ANCHURA (BFS):     " + r.enAnchura("978-0000000001", 3));
        System.out.println("PROFUNDIDAD (DFS): " + r.enProfundidad("978-0000000001", 3));
    }
}

ANCHURA (BFS):     [978-0000000002, DVD-0007, 978-0000000003, REV-2024-03]
PROFUNDIDAD (DFS): [DVD-0007, REV-2024-03, 978-0000000002, 978-0000000003]