0Pricing
Java Academy · Lección

PriorityQueue para el procesamiento ordenado

Use PriorityQueue con orden natural y comparadores personalizados en situaciones de planificación de tareas.

PriorityQueue para el procesamiento ordenado es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

¿Qué es PriorityQueue?

PriorityQueue es un min-heap de forma predeterminada: el elemento con el orden natural más bajo siempre se encuentra en la cabeza. Los elementos no se ordenan internamente; solo se garantiza que el mínimo está al frente.

import java.util.PriorityQueue;

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(30);
pq.offer(10);
pq.offer(20);

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

Estructura interna del heap

PriorityQueue utiliza un min-heap binario almacenado en un array. El padre en el índice i siempre es ≤ que sus hijos en 2i+1 y 2i+2. Esto garantiza un coste O(log n) para offer/poll y O(1) para peek.

Max-heap con comparador inverso

Para crear un max-heap (el elemento más grande primero), pase Comparator.reverseOrder():

PriorityQueue<Integer> maxPQ = new PriorityQueue<>(Comparator.reverseOrder());
maxPQ.offer(10);
maxPQ.offer(50);
maxPQ.offer(30);

System.out.println(maxPQ.poll()); // 50 (max)
System.out.println(maxPQ.poll()); // 30

PriorityQueue con objetos personalizados

Utilice un comparador para ordenar registros o clases personalizados:

record Job(String name, int priority) {}

PriorityQueue<Job> queue = new PriorityQueue<>(
    Comparator.comparingInt(Job::priority) // ascending priority
);
queue.offer(new Job("Backup", 5));
queue.offer(new Job("Alert", 1));
queue.offer(new Job("Report", 3));

System.out.println(queue.poll().name()); // Alert (priority 1)

Peek frente a Poll

peek() devuelve el elemento de la cabeza sin eliminarlo. poll() lo elimina y lo devuelve. Ambos devuelven null cuando la cola está vacía (a diferencia de element()/remove(), que lanzan una excepción).

PriorityQueue<String> pq = new PriorityQueue<>();
pq.offer("banana");
pq.offer("apple");

System.out.println(pq.peek()); // apple (not removed)
System.out.println(pq.peek()); // apple (still there)
System.out.println(pq.poll()); // apple (removed)
System.out.println(pq.peek()); // banana

Ejemplo de planificación de tareas

PriorityQueue es ideal para simulaciones de planificación de CPU en las que las tareas tienen distintas prioridades:

record Task(String name, int priority) {}

PriorityQueue<Task> scheduler = new PriorityQueue<>(
    Comparator.comparingInt(Task::priority).reversed() // highest first
);
scheduler.offer(new Task("Low", 1));
scheduler.offer(new Task("Critical", 10));
scheduler.offer(new Task("Normal", 5));

while (!scheduler.isEmpty()) {
    System.out.println("Processing: " + scheduler.poll().name());
}
// Critical, Normal, Low

Los K elementos más pequeños

PriorityQueue es una herramienta clásica para encontrar los K elementos más pequeños sin ordenar completamente el array:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int n : nums) pq.offer(n);

for (int i = 0; i < k; i++) {
    System.out.print(pq.poll() + " ");
}
// 1 2 3

Los K elementos más grandes con un max-heap

Como alternativa, mantenga un min-heap de tamaño K mientras itera para encontrar los K elementos más grandes:

int[] nums = {7, 2, 5, 1, 9, 3, 8};
int k = 3;

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
for (int n : nums) {
    minHeap.offer(n);
    if (minHeap.size() > k) minHeap.poll(); // remove smallest
}
// minHeap now contains the 3 largest: [7, 8, 9]
System.out.println(minHeap); // order may vary

Patrón del algoritmo de Dijkstra

El algoritmo de rutas más cortas de Dijkstra se basa en un min-heap para expandir siempre primero el nodo no visitado de menor coste:

record Entry(int node, int cost) {}

PriorityQueue<Entry> pq = new PriorityQueue<>(
    Comparator.comparingInt(Entry::cost)
);
pq.offer(new Entry(0, 0)); // start node, cost 0

while (!pq.isEmpty()) {
    Entry curr = pq.poll();
    System.out.println("Visit node " + curr.node() + " cost=" + curr.cost());
    // expand neighbors...
}

La iteración no está ordenada

Iterar sobre una PriorityQueue NO devuelve los elementos en orden de prioridad; solo poll() lo hace. Para obtener una salida ordenada, extraiga elementos repetidamente con poll en lugar de utilizar for-each.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.addAll(List.of(5,3,1,4,2));

// WRONG for sorted output:
for (int n : pq) System.out.print(n+" "); // unordered!

// CORRECT:
while (!pq.isEmpty()) System.out.print(pq.poll()+" "); // 1 2 3 4 5

Resumen del rendimiento

Complejidad de las operaciones de PriorityQueue:

  • offer(e): O(log n)
  • poll(): O(log n)
  • peek(): O(1)
  • contains(e): O(n)
  • remove(e): O(n)

No es segura para subprocesos; utilice PriorityBlockingQueue para el acceso concurrente.

Comprobación rápida

¿Qué garantiza sobre el orden de los elementos iterar una PriorityQueue con un bucle for-each?

Repaso: PriorityQueue

Aspectos clave:

  • PriorityQueue es un min-heap: el elemento más pequeño se extrae primero
  • Utilice Comparator.reverseOrder() para obtener un max-heap
  • offer/poll tienen un coste O(log n) y peek, O(1)
  • Casos de uso clásicos: K-ésimo elemento más grande o más pequeño, Dijkstra y planificación de tareas
  • for-each no proporciona el orden de prioridad; utilice poll()

Preguntas frecuentes

¿La lección «PriorityQueue para el procesamiento ordenado» es gratis?

Sí — el texto completo de «PriorityQueue para el procesamiento ordenado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «PriorityQueue para el procesamiento ordenado»?

Use PriorityQueue con orden natural y comparadores personalizados en situaciones de planificación de tareas. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «PriorityQueue para el procesamiento ordenado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Aspectos internos de LinkedList
  2. Operaciones de Deque: pila y cola
  3. LinkedList frente a ArrayList: ventajas y desventajas
  4. PriorityQueue para el procesamiento ordenado
← Volver a Java Academy