Java Academy · Lección

Operaciones de Deque: pila y cola

Use LinkedList como Deque para implementar el comportamiento de pila (push/pop) y de cola (offer/poll).

Operaciones de Deque: pila y cola es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 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.

Deque: cola de doble extremo

Una Deque (cola de doble extremo) permite realizar inserciones y eliminaciones en ambos extremos. La interfaz Deque de Java está implementada por LinkedList y ArrayDeque.

import java.util.Deque;
import java.util.ArrayDeque;

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("A"); // front
deque.addLast("B");  // back
deque.addFirst("Z"); // new front

System.out.println(deque); // [Z, A, B]

ArrayDeque frente a LinkedList como Deque

Generalmente se prefiere ArrayDeque a LinkedList como Deque:

No hay sobrecarga de nodos por elemento
Mejor localidad de caché
Algo más rápida para operaciones de pila y cola

Elija LinkedList únicamente cuando también necesite la interfaz List.

Operaciones de pila con Deque

Utilice push (addFirst) y pop (removeFirst) para simular una pila LIFO. Evite la clase Stack antigua: está sincronizada y obsoleta.

Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.push(3);

System.out.println(stack.pop());  // 3
System.out.println(stack.peek()); // 2 (no removal)
System.out.println(stack.pop());  // 2

Operaciones de cola con Deque

Utilice offer (addLast) y poll (removeFirst) para simular una cola FIFO. offer devuelve false si falla; add lanza una excepción.

Deque<String> queue = new ArrayDeque<>();
queue.offer("task1");
queue.offer("task2");
queue.offer("task3");

System.out.println(queue.poll());  // task1
System.out.println(queue.poll());  // task2
System.out.println(queue.size());  // 1

Tabla de referencia de métodos de Deque

Deque proporciona dos familias de métodos: una lanza excepciones y la otra devuelve valores especiales:

addFirst/addLast frente a offerFirst/offerLast
removeFirst/removeLast frente a pollFirst/pollLast
getFirst/getLast frente a peekFirst/peekLast

Prefiera la familia offer/poll/peek para evitar excepciones cuando las Deque estén vacías.

Ejemplo real: deshacer y rehacer con dos pilas

Un caso de uso clásico de Deque: el historial de deshacer es una pila. Rehacer es otra pila.

Deque<String> undo = new ArrayDeque<>();
Deque<String> redo = new ArrayDeque<>();

undo.push("type 'Hello'");
undo.push("type ' World'");

String action = undo.pop();
System.out.println("Undone: " + action); // type ' World'
redo.push(action);

System.out.println("Redo top: " + redo.peek()); // type ' World'

Comprobación de palíndromos con Deque

Las Deque hacen elegante la comprobación de palíndromos: permiten comparar simultáneamente los caracteres de ambos extremos.

Deque<Character> deque = new ArrayDeque<>();
for (char c : "racecar".toCharArray()) deque.add(c);

boolean isPalindrome = true;
while (deque.size() > 1) {
    if (!deque.pollFirst().equals(deque.pollLast())) {
        isPalindrome = false;
        break;
    }
}
System.out.println(isPalindrome); // true

BFS con una cola

La búsqueda en anchura (BFS) utiliza una cola. ArrayDeque es la opción estándar para BFS en programación competitiva y recorrido de grafos.

import java.util.*;

// BFS on a simple adjacency list
Map<Integer,List<Integer>> graph = Map.of(
    1, List.of(2,3),
    2, List.of(4),
    3, List.of(4),
    4, List.of()
);
Deque<Integer> queue = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
queue.offer(1);
while (!queue.isEmpty()) {
    int node = queue.poll();
    if (visited.add(node)) {
        System.out.print(node + " ");
        queue.addAll(graph.get(node));
    }
}

DFS con una pila

La búsqueda en profundidad (DFS) utiliza una pila. De nuevo, prefiera ArrayDeque a la clase Stack antigua.

Deque<Integer> stack = new ArrayDeque<>();
Set<Integer> visited = new HashSet<>();
stack.push(1);
while (!stack.isEmpty()) {
    int node = stack.pop();
    if (visited.add(node)) {
        System.out.print(node + " ");
        // push neighbors (will be processed in reverse order)
        List<Integer> neighbors = List.of(2, 3); // simplified
        for (int n : neighbors) if (!visited.contains(n)) stack.push(n);
    }
}

Deque acotada con comprobación de tamaño

ArrayDeque crece dinámicamente, pero puede imponer manualmente una capacidad para simular un búfer acotado:

Deque<Integer> buffer = new ArrayDeque<>();
int MAX = 3;

for (int i = 1; i <= 5; i++) {
    if (buffer.size() >= MAX) {
        buffer.pollFirst(); // drop oldest
    }
    buffer.offerLast(i);
}
System.out.println(buffer); // [3, 4, 5]

Notas de rendimiento

ArrayDeque utiliza un array circular que duplica su tamaño cuando se llena. El coste amortizado de todas las operaciones es O(1). Supera a LinkedList en la mayoría de las pruebas de rendimiento gracias a la eficiencia de la caché. Nunca sincronice manualmente: utilice ConcurrentLinkedDeque o una cola bloqueante para la concurrencia.

Comprobación rápida

¿Qué clase debería preferir a la clase Stack antigua para operaciones LIFO?

Recapitulación: operaciones de Deque

Aspectos clave:

Deque permite realizar inserciones y eliminaciones O(1) en ambos extremos
Se prefiere ArrayDeque a LinkedList para utilizarla exclusivamente como pila o cola
push/pop → pila LIFO; offer/poll → cola FIFO
Usos clásicos: deshacer/rehacer, BFS/DFS, ventana deslizante y comprobación de palíndromos
Evite las clases Stack y Queue antiguas

Preguntas frecuentes

¿La lección «Operaciones de Deque: pila y cola» es gratis?

Sí — el texto completo de «Operaciones de Deque: pila y cola» 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 «Operaciones de Deque: pila y cola»?

Use LinkedList como Deque para implementar el comportamiento de pila (push/pop) y de cola (offer/poll). 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 2 de 4.

¿Cuánto tiempo toma la lección «Operaciones de Deque: pila y cola»?

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

Aspectos internos de LinkedList
Operaciones de Deque: pila y cola
LinkedList frente a ArrayList: ventajas y desventajas
PriorityQueue para el procesamiento ordenado

← Volver a Java Academy