Stack, Queue, and Deque in Java

📚 Stack, Queue, and Deque in Java

When working with data in Java, understanding the Stack, Queue, and Deque in Java is essential. These data structures organize elements in specific orders to solve different problems efficiently. Let’s explore how each works and their common use cases.

🔼 What is a Stack?

A Stack follows the Last-In-First-Out (LIFO) principle. Elements are added (pushed) and removed (popped) only from the top of the stack. This behavior is useful for scenarios like undo mechanisms, expression evaluation, and backtracking algorithms.

import java.util.Stack;

Stack<String> stack = new Stack<>();
stack.push("Java");
stack.push("Python");
stack.push("C++");

System.out.println(stack.pop());  // Outputs: C++
System.out.println(stack.peek()); // Outputs: Python (top element without removing)

➡️ What is a Queue?

A Queue follows the First-In-First-Out (FIFO) principle. Elements are added (offered) at the end and removed (polled) from the front. Queues are great for scheduling tasks, handling requests, or managing data buffers.

import java.util.LinkedList;
import java.util.Queue;

Queue<Integer> queue = new LinkedList<>();
queue.offer(10);
queue.offer(20);
queue.offer(30);

System.out.println(queue.poll());  // Outputs: 10
System.out.println(queue.peek());  // Outputs: 20 (front element without removing)

🔄 What is a Deque?

A Deque (Double Ended Queue) supports adding and removing elements from both ends. This flexibility makes it ideal for scenarios like sliding window algorithms, undo operations, and palindrome checking.

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

Deque<String> deque = new ArrayDeque<>();
deque.addFirst("Front");
deque.addLast("Back");

System.out.println(deque.removeFirst()); // Outputs: Front
System.out.println(deque.removeLast());  // Outputs: Back

⚙️ Key Operations Summary

• Stack: push(), pop(), peek()
• Queue: offer(), poll(), peek()
• Deque: addFirst(), addLast(), removeFirst(), removeLast()

📝 When to Use Which?

• Use a Stack when you need LIFO behavior, like undo functionality or recursive algorithm simulation.
• Use a Queue when order matters and processing happens in the sequence elements arrive.
• Use a Deque when you need flexibility to add or remove elements from both ends.

🚀 Conclusion

Mastering Stack, Queue, and Deque in Java helps build efficient and well-organized programs. By choosing the right data structure for your needs, you optimize both performance and code clarity.