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

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

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

System.out.println(pendents.peek());      // Marta Ruiz  (mira sense treure)
System.out.println(pendents.poll());      // Marta Ruiz  (treu)
System.out.println(pendents.poll());      // Diego Alonso
System.out.println(pendents.size());      // 1

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

// Bucle de proces: que la cua es buidi es NORMAL, es la condicio de parada
Reserva r;
while ((r = cua.poll()) != null) {        // poll retorna null: idiomatic i net
    atendre(r);
}

// Consulta puntual on buida SERIA un error de logica
Reserva seguent = cua.remove();           // NoSuchElementException si es buida

tail = (tail + 1) & (elements.length - 1);   // torna a 0 en passar del final

// Com a CUA (FIFO): entra pel final, surt pel principi
Deque<String> cua = new ArrayDeque<>();
cua.offerLast("Marta Ruiz");
cua.offerLast("Diego Alonso");
System.out.println(cua.pollFirst());      // Marta Ruiz

// Com a PILA (LIFO): entra i surt pel mateix extrem
Deque<String> pila = new ArrayDeque<>();
pila.push("alta");
pila.push("baixa");
System.out.println(pila.pop());           // baixa  (l'ultima que va entrar)

// Com a DEQUE de debo: els dos extrems
Deque<String> doble = new ArrayDeque<>();
doble.offerFirst("urgent");               // es cola al principi
doble.offerLast("normal");                // espera el seu torn al final
System.out.println(doble.pollFirst());    // urgent

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

// Per ordre natural: el MENOR surt primer
Queue<Integer> cua = new PriorityQueue<>();
cua.offer(30);
cua.offer(10);
cua.offer(20);

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

// Els prestecs amb MES dies de retard primer
Queue<Prestec> avisos = new PriorityQueue<>(
    Comparator.comparingInt((Prestec p) -> p.diesRetard(diaActual)).reversed());

// Les reserves mes urgents primer i, a igualtat, les mes antigues
Queue<Reserva> reserves = new PriorityQueue<>(
    Comparator.comparingInt(Reserva::getPrioritat)
              .thenComparingInt(Reserva::getDiaSollicitud));

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

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

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

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

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

while (!cua.isEmpty()) {
    Prestec p = cua.poll();        // en ordre de prioritat garantit
    processar(p);
}
// ...pero la cua queda buida

Queue<Prestec> copia = new PriorityQueue<>(cua);    // copia el monticle
while (!copia.isEmpty()) {
    processar(copia.poll());
}
// la cua original continua intacta

List<Prestec> ordenats = new ArrayList<>(cua);
ordenats.sort(cua.comparator());         // el mateix criteri de la cua

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

void registrar(String operacio) {
    ultimesOperacions.offerLast(operacio);
    if (ultimesOperacions.size() > 100) {
        ultimesOperacions.pollFirst();       // O(1): descarta la mes antiga
    }
}

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

Runnable tasca;
while ((tasca = tasques.poll()) != null) {
    tasca.run();          // s'executen en ordre d'arribada
}

package com.nexussoftware.bibliotech.servei;

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 Recomanador {

    /** Graf: referencia -> referencies relacionades. */
    private final Map<String, List<String>> relacionats;

    public Recomanador(Map<String, List<String>> relacionats) {
        this.relacionats = relacionats;
    }

    /**
     * Recorregut en amplada: retorna les referencies assolibles des d'"origen"
     * fins a "profunditatMaxima" salts, en ordre de PROXIMITAT.
     */
    public List<String> recomanar(String origen, int profunditatMaxima) {
        List<String> resultat = new ArrayList<>();
        Set<String>  visitats = new HashSet<>();
        Deque<String> perVisitar = new ArrayDeque<>();
        Deque<Integer> profunditats = new ArrayDeque<>();

        perVisitar.offerLast(origen);
        profunditats.offerLast(0);
        visitats.add(origen);

        while (!perVisitar.isEmpty()) {
            String actual = perVisitar.pollFirst();          // FIFO: per nivells
            int profunditat = profunditats.pollFirst();

            if (profunditat > 0) { resultat.add(actual); }   // l'origen no es recomana
            if (profunditat >= profunditatMaxima) { continue; }

            for (String vei : relacionats.getOrDefault(actual, List.of())) {
                if (visitats.add(vei)) {     // add retorna false si ja hi era (05-06)
                    perVisitar.offerLast(vei);
                    profunditats.offerLast(profunditat + 1);
                }
            }
        }
        return resultat;
    }
}

Map<String, List<String>> graf = Map.of(
    "978-0000000001", List.of("978-0000000002", "978-0000000003"),   // Java Eficac
    "978-0000000002", List.of("978-0000000003", "DVD-0007"),         // Patrons
    "978-0000000003", List.of("DVD-0007"),                           // Refactoritzacio
    "DVD-0007",       List.of("REV-2024-03")
);

Recomanador r = new Recomanador(graf);
System.out.println(r.recomanar("978-0000000001", 1));    // veins directes
System.out.println(r.recomanar("978-0000000001", 3));    // fins a 3 salts, per proximitat

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

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import com.nexussoftware.bibliotech.domini.Empleat;
import com.nexussoftware.bibliotech.domini.Material;
import com.nexussoftware.bibliotech.domini.Reserva;

/**
 * Cua FIFO de reserves d'UN material, sobre ArrayDeque.
 *
 * Enfront de la versio amb LinkedList de 05-04: mateix O(1) als extrems,
 * pero amb un array circular en lloc de nodes -> menys memoria, millor
 * localitat de memoria cau i cap pressio sobre el recollidor.
 */
public class CuaReserves {

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

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

    /** Encuar pel final: O(1) amortitzat. */
    public void reservar(Empleat empleat, int dia) {
        pendents.offerLast(new Reserva(empleat, material, dia));
    }

    /** Reserva urgent: es cola per davant. Nomes un Deque permet aixo. */
    public void reservarUrgent(Empleat empleat, int dia) {
        pendents.offerFirst(new Reserva(empleat, material, dia, 1));
    }

    /** peekFirst: null si no hi ha ningu. No llanca mai excepcio. */
    public Reserva seguent() {
        return pendents.peekFirst();
    }

    /** pollFirst: aten i treu. O(1). */
    public Reserva atendreSeguent(int dia) {
        Reserva r = pendents.pollFirst();
        if (r != null) {
            r.marcarAtesa();
            material.prestar();
        }
        return r;
    }

    /** Cancella la reserva mes recent d'un empleat, recorrent des del final. */
    public boolean cancellarUltimaDe(Empleat empleat) {
        Iterator<Reserva> it = pendents.descendingIterator();
        while (it.hasNext()) {
            if (it.next().getEmpleat().equals(empleat)) {
                it.remove();
                return true;
            }
        }
        return false;
    }

    /** Caduca les reserves que fa massa temps que esperen. */
    public int caducar(int diaActual, int diesMaxims) {
        int abans = pendents.size();
        pendents.removeIf(r -> r.diesEnEspera(diaActual) > diesMaxims);
        return abans - pendents.size();
    }

    /** Posicio a la cua (1 = el seguent). 0 si no te reserva. */
    public int posicioDe(Empleat empleat) {
        int posicio = 1;
        for (Reserva r : pendents) {        // un Deque NO te get(i): sempre for-each
            if (r.getEmpleat().equals(empleat)) { return posicio; }
            posicio++;
        }
        return 0;
    }

    public List<Reserva> llistar() { return new ArrayList<>(pendents); }
    public int     enEspera()      { return pendents.size(); }
    public boolean hiHaPendents()  { return !pendents.isEmpty(); }
}

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import com.nexussoftware.bibliotech.domini.Gravetat;
import com.nexussoftware.bibliotech.domini.Prestec;

/** Avisos de venciment atesos per urgencia, no per ordre d'arribada. */
public class CuaAvisos {

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

    public CuaAvisos(int diaActual) {
        this.diaActual = diaActual;
        // Mes dies de retard primer; a igualtat, el prestec mes antic.
        // El desempat fa l'ordre DETERMINISTA: sense ell, dos prestecs amb
        // el mateix retard sortirien en ordre arbitrari.
        this.avisos = new PriorityQueue<>(
            Comparator.comparingInt((Prestec p) -> diesRetard(p)).reversed()
                      .thenComparingInt(Prestec::getDiaPrestec));
    }

    private int diesRetard(Prestec p) {
        return p.getMaterial().calcularDiesRetard(diaActual - p.getDiaPrestec());
    }

    /** Encua nomes el que esta realment vencut. O(log n). */
    public void encuar(Prestec p) {
        if (p != null && !p.estaRetornat() && p.estaVencut(diaActual)) {
            avisos.offer(p);
        }
    }

    public void encuarTots(List<Prestec> prestecs) {
        for (Prestec p : prestecs) { encuar(p); }
    }

    /** El mes urgent, sense treure'l. O(1). */
    public Prestec mesUrgent() {
        return avisos.peek();
    }

    /**
     * Processa TOTS els avisos en ordre d'urgencia.
     *
     * IMPORTANT: cal buidar la cua amb poll(). Recorrer-la amb for-each
     * o imprimir el seu toString() donaria l'ordre del monticle intern, que NO
     * es l'ordre de prioritat.
     */
    public int processarTots() {
        int processats = 0;
        Prestec p;
        while ((p = avisos.poll()) != null) {      // idioma de l'apartat 2
            int retard = diesRetard(p);
            Gravetat g = p.getMaterial().classificarGravetat(diaActual - p.getDiaPrestec());
            System.out.printf("[%-10s] %-16s %-24s %3d dies  %6.2f EUR%n",
                    g, p.getEmpleat().getNom(), p.getMaterial().getTitol(),
                    retard, p.calcularMulta(diaActual));
            processats++;
        }
        return processats;
    }

    /** Els N mes urgents, SENSE buidar la cua: es treballa sobre una copia. */
    public List<Prestec> topUrgents(int quants) {
        Queue<Prestec> copia = new PriorityQueue<>(avisos);   // copia el monticle
        List<Prestec> resultat = new ArrayList<>();
        for (int i = 0; i < quants && !copia.isEmpty(); i++) {
            resultat.add(copia.poll());
        }
        return resultat;
    }

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

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

Material javaEficac = new Llibre("Java Eficac", "Joshua Bloch", "978-0000000001", 2018);

// --- Cua de reserves (FIFO) ---
javaEficac.prestar();
CuaReserves reserves = new CuaReserves(javaEficac);
reserves.reservar(marta, 100);
reserves.reservar(diego, 101);
reserves.reservarUrgent(nuria, 102);         // es cola per davant

System.out.println("Seguent: " + reserves.seguent().getEmpleat().getNom());
System.out.println("Posicio de Marta: " + reserves.posicioDe(marta));

// --- Cua d'avisos (per prioritat) ---
List<Prestec> prestecs = List.of(
    new Prestec(new Llibre("Java Eficac",        "Joshua Bloch",  "978-0000000001", 2018), marta, 100),
    new Prestec(new Revista("Java Magazine",     "REV-2024-03",   42, "Mensual"),          diego, 120),
    new Prestec(new Dvd("Refactoritzacio en directe", "DVD-0007", 95),                     nuria, 125),
    new Prestec(new Llibre("Patrons de Disseny", "Erich Gamma",   "978-0000000002", 1994), diego, 110)
);

CuaAvisos avisos = new CuaAvisos(140);
avisos.encuarTots(prestecs);
System.out.println("\nAvisos pendents: " + avisos.pendents());
System.out.println("Mes urgent: " + avisos.mesUrgent().getMaterial().getTitol());
System.out.println("\n--- Processant per urgencia ---");
avisos.processarTots();

Seguent: Nuria Vidal
Posicio de Marta: 2

Avisos pendents: 4
Mes urgent: Java Magazine

--- Processant per urgencia ---
[GREU      ] Diego Alonso     Java Magazine             13 dies    1.30 EUR
[GREU      ] Nuria Vidal      Refactoritzacio en directe  12 dies    6.00 EUR
[GREU      ] Marta Ruiz       Java Eficac               25 dies    6.25 EUR
[GREU      ] Diego Alonso     Patrons de Disseny        15 dies    3.75 EUR

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import com.nexussoftware.bibliotech.domini.Empleat;

/** Sala d'espera del taulell de prestecs. */
public class SalaEspera {

    private final Deque<Empleat> cua = new ArrayDeque<>();

    /** O(1) amortitzat: escriure a 'tail' i incrementar-lo. */
    public void arribar(Empleat e) {
        if (e != null) { cua.offerLast(e); }
    }

    /**
     * O(1): escriure a 'head-1' i decrementar-lo (l'array es CIRCULAR,
     * aixi que 'head' pot fer la volta al final de l'array).
     * Amb un ArrayList aixo seria add(0, e): O(n).
     */
    public void arribarPrioritari(Empleat e) {
        if (e != null) { cua.offerFirst(e); }
    }

    /** O(1). pollFirst retorna null si es buida; removeFirst llancaria excepcio. */
    public Empleat atendre() {
        return cua.pollFirst();
    }

    /** O(1). */
    public Empleat seguent() {
        return cua.peekFirst();
    }

    /**
     * O(n): cal recorrer la cua buscant l'empleat. Es l'unica
     * operacio cara d'aquesta classe, i es acceptable perque marxar a mitja
     * cua es excepcional.
     */
    public boolean marxar(Empleat e) {
        return cua.removeFirstOccurrence(e);    // usa equals (03-09)
    }

    /** O(n). Un Deque no te get(i): la posicio nomes se sap recorrent. */
    public int posicioDe(Empleat e) {
        int posicio = 1;
        for (Empleat actual : cua) {
            if (actual.equals(e)) { return posicio; }
            posicio++;
        }
        return 0;
    }

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

    /** Buida la cua atenent en ordre. Idioma estandard amb poll. */
    public void tancarMostrador() {
        System.out.println("--- Tancant mostrador: " + cua.size() + " en espera ---");
        Empleat e;
        int torn = 1;
        while ((e = cua.pollFirst()) != null) {
            System.out.printf("  Torn %d: %s (%s)%n",
                              torn++, e.getNom(), e.getIdentificador());
        }
        System.out.println("--- Mostrador tancat ---");
    }

    public int     enEspera() { return cua.size(); }
    public boolean buida()    { return cua.isEmpty(); }
}

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

SalaEspera sala = new SalaEspera();
sala.arribar(marta);
sala.arribar(diego);
sala.arribarPrioritari(nuria);          // es cola per davant

System.out.println("Seguent: " + sala.seguent().getNom());              // Nuria Vidal
System.out.println("Posicio de Marta: " + sala.posicioDe(marta));       // 2
System.out.println("Diego marxa: " + sala.marxar(diego));               // true
sala.tancarMostrador();

Seguent: Nuria Vidal
Posicio de Marta: 2
Diego marxa: true
--- Tancant mostrador: 2 en espera ---
  Torn 1: Nuria Vidal (EMP-003)
  Torn 2: Marta Ruiz (EMP-001)
--- Mostrador tancat ---

package com.nexussoftware.bibliotech.servei;

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

/** Tasca de manteniment del cataleg. Prioritat 1 = maxima urgencia. */
record TascaManteniment(String descripcio, int prioritat, int diaCreacio) {
    TascaManteniment {
        if (descripcio == null || descripcio.isBlank()) { descripcio = "(sense descripcio)"; }
        if (prioritat < 1 || prioritat > 10) { prioritat = 5; }
        if (diaCreacio < 0) { diaCreacio = 0; }
    }
}

public class PlanificadorTasques {

    private final Queue<TascaManteniment> cua;

    public PlanificadorTasques() {
        // Menor numero de prioritat primer. A igualtat, la mes antiga.
        // El desempat fa l'ordre DETERMINISTA i a mes just: entre dues
        // urgencies iguals, guanya la que fa mes temps que espera.
        this.cua = new PriorityQueue<>(
            Comparator.comparingInt(TascaManteniment::prioritat)
                      .thenComparingInt(TascaManteniment::diaCreacio));
    }

    /** O(log n): l'element sura cap amunt al monticle. */
    public void programar(TascaManteniment t) {
        if (t != null) { cua.offer(t); }
    }

    /** O(1): l'arrel del monticle. */
    public TascaManteniment seguent() {
        return cua.peek();
    }

    /** O(log n): treu l'arrel i reorganitza. */
    public TascaManteniment executar() {
        return cua.poll();
    }

    /**
     * Les N seguents SENSE buidar la cua original.
     * El constructor de copia de PriorityQueue duplica el monticle.
     */
    public List<TascaManteniment> properes(int quantes) {
        Queue<TascaManteniment> copia = new PriorityQueue<>(cua);
        List<TascaManteniment> resultat = new ArrayList<>();
        for (int i = 0; i < quantes && !copia.isEmpty(); i++) {
            resultat.add(copia.poll());
        }
        return resultat;
    }

    public int executarTotes() {
        int n = 0;
        TascaManteniment t;
        while ((t = cua.poll()) != null) {
            System.out.printf("  [P%d] dia %3d  %s%n", t.prioritat(), t.diaCreacio(),
                              t.descripcio());
            n++;
        }
        return n;
    }

    /** Demostra que nomes poll() respecta l'ordre de prioritat. */
    public void demostrarIteradorNoOrdenat() {
        System.out.println("=== L'iterador NO recorre en ordre de prioritat ===");

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

        System.out.print("for-each:  ");
        for (TascaManteniment t : cua) { System.out.print("P" + t.prioritat() + " "); }
        System.out.println();

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

        System.out.print("poll:      ");
        Queue<TascaManteniment> copia = new PriorityQueue<>(cua);
        TascaManteniment t;
        while ((t = copia.poll()) != null) { System.out.print("P" + t.prioritat() + " "); }
        System.out.println("   <- l'UNIC ordre garantit");

        System.out.println("Causa: l'array intern nomes compleix la propietat de monticle");
        System.out.println("(cada node <= els seus fills), no un ordre total.");
    }

    public int pendents() { return cua.size(); }
}

PlanificadorTasques p = new PlanificadorTasques();
p.programar(new TascaManteniment("Revisar exemplars deteriorats",  5, 100));
p.programar(new TascaManteniment("Reposar DVD malmes",             1, 130));
p.programar(new TascaManteniment("Inventari anual",                8, 90));
p.programar(new TascaManteniment("Actualitzar ISBN erronis",       1, 110));
p.programar(new TascaManteniment("Netejar prestatgeries",          5, 95));

System.out.println("Seguent: " + p.seguent().descripcio());
System.out.println("Properes 2: ");
p.properes(2).forEach(t -> System.out.println("  " + t.descripcio()));
System.out.println("Pendents despres de consultar: " + p.pendents());

p.demostrarIteradorNoOrdenat();
System.out.println("\n--- Executant totes ---");
p.executarTotes();

Seguent: Actualitzar ISBN erronis
Properes 2:
  Actualitzar ISBN erronis
  Reposar DVD malmes
Pendents despres de consultar: 5

=== L'iterador NO recorre en ordre de prioritat ===
toString():
  [TascaManteniment[...prioritat=1, diaCreacio=110], ...]
for-each:  P1 P1 P8 P5 P5
forEach:   P1 P1 P8 P5 P5
poll:      P1 P1 P5 P5 P8    <- l'UNIC ordre garantit
...
--- Executant totes ---
  [P1] dia 110  Actualitzar ISBN erronis
  [P1] dia 130  Reposar DVD malmes
  [P5] dia  95  Netejar prestatgeries
  [P5] dia 100  Revisar exemplars deteriorats
  [P8] dia  90  Inventari anual

package com.nexussoftware.bibliotech.servei;

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 RecomanadorComparat {

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

    public RecomanadorComparat(Map<String, List<String>> relacionats) {
        this.relacionats = relacionats;
    }

    /**
     * AMPLADA (BFS): cua FIFO. Explora per NIVELLS: primer tots els
     * veins directes, despres els veins d'aquests, etc.
     */
    public List<String> enAmplada(String origen, int profunditatMaxima) {
        return recorrer(origen, profunditatMaxima, true);
    }

    /**
     * PROFUNDITAT (DFS): pila LIFO. Baixa tot el que pot per una branca
     * abans de tornar enrere. MATEIX codi, nomes canvia per quin extrem es treu.
     */
    public List<String> enProfunditat(String origen, int profunditatMaxima) {
        return recorrer(origen, profunditatMaxima, false);
    }

    private List<String> recorrer(String origen, int profunditatMaxima, boolean amplada) {
        List<String>   resultat     = new ArrayList<>();
        Set<String>    visitats     = new HashSet<>();
        Deque<String>  perVisitar   = new ArrayDeque<>();
        Deque<Integer> profunditats = new ArrayDeque<>();

        perVisitar.offerLast(origen);
        profunditats.offerLast(0);
        visitats.add(origen);

        while (!perVisitar.isEmpty()) {
            // L'UNICA DIFERENCIA entre BFS i DFS es en aquesta linia:
            //   pollFirst -> FIFO -> amplada
            //   pollLast  -> LIFO -> profunditat
            String actual = amplada ? perVisitar.pollFirst() : perVisitar.pollLast();
            int profunditat = amplada ? profunditats.pollFirst() : profunditats.pollLast();

            if (profunditat > 0) { resultat.add(actual); }
            if (profunditat >= profunditatMaxima) { continue; }

            for (String vei : relacionats.getOrDefault(actual, List.of())) {
                if (visitats.add(vei)) {          // add retorna false si ja hi era (05-06)
                    perVisitar.offerLast(vei);
                    profunditats.offerLast(profunditat + 1);
                }
            }
        }
        return resultat;
    }

    public static void main(String[] args) {
        Map<String, List<String>> graf = 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")
        );

        RecomanadorComparat r = new RecomanadorComparat(graf);
        System.out.println("AMPLADA (BFS):     " + r.enAmplada("978-0000000001", 3));
        System.out.println("PROFUNDITAT (DFS): " + r.enProfunditat("978-0000000001", 3));
    }
}

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