Various Operations on Queue Using Stack in Java

Fundamental data structures used in computer programming to organise collections of elements in a specific sequence include queues and stacks. The use of two stacks to create a queue is feasible even though they are typically used separately. This essay will examine the different operations that can be carried out on a queue in Java using stacks.

Creating a Queue Using Stacks in Java

Two stacks are required to implement a queue in Java using stacks: one to store newly inserted elements, and another to reverse the order of elements when they are removed from the queue. Here's an illustration:

Stack<Integer> inputStack = new Stack<Integer>();
Stack<Integer> outputStack = new Stack<Integer>();

Adding Elements to a Queue Using Stacks

Using stacks, we can easily push an element onto the input stack to add it to the end of the queue. Here's an illustration:

inputStack.push(1);
inputStack.push(2);
inputStack.push(3);

Removing Elements from a Queue Using Stacks

Using stacks, we need to transfer all the elements from the input stack onto the output stack in reverse order before we can remove an element from the front of the queue. The element at the head of the queue can then be obtained by popping the top element from the output array. Here's an illustration:

while (!inputStack.isEmpty()) {
    outputStack.push(inputStack.pop());
}
int frontElement = outputStack.pop();

Retrieving the Element at the Front of the Queue Using Stacks

The same steps as for removing an element from the front of the queue can be used to retrieve the top element of a queue using stacks, but instead of popping the top element from the output stack, we can just look at it. Here's an illustration:

while (!inputStack.isEmpty()) {
    outputStack.push(inputStack.pop());
}
int frontElement = outputStack.peek();

Iterating over a Queue Using Stacks

By iterating over the input stack and then the output stack, we can loop through a list using stacks. Here's an illustration:

Iterator<Integer> inputIterator = inputStack.iterator();
while (inputIterator.hasNext()) {
    System.out.println(inputIterator.next());
}
Iterator<Integer> outputIterator = outputStack.iterator();
while (outputIterator.hasNext()) {
    System.out.println(outputIterator.next());
}

QueueExample.java

import java.util.Stack;
public class QueueExample {
    public static void main(String[] args) {
        Stack<Integer> inputStack = new Stack<Integer>();
        Stack<Integer> outputStack = new Stack<Integer>();
        // Add elements to the queue
        inputStack.push(1);
        inputStack.push(2);
        inputStack.push(3);
        System.out.println("Queue after adding elements: " + inputStack);
        // Remove elements from the front of the queue
        while (!inputStack.isEmpty()) {
            outputStack.push(inputStack.pop());
        }
        int removedElement1 = outputStack.pop();
        int removedElement2 = outputStack.pop();
        System.out.println("Queue after removing elements: " + outputStack);
        // Retrieve the element at the front of the queue
        while (!inputStack.isEmpty()) {
            outputStack.push(inputStack.pop());
        }
        int frontElement = outputStack.peek();
        System.out.println("Front element of the queue: " + frontElement);
        // Iterate over the queue
        System.out.println("Iterating over the queue:");
        for (int element : outputStack) {
            System.out.println(element);
        }
    }
}

Output:

Queue after adding elements: [1, 2, 3]
Queue after removing elements: [3, 2]
Front element of the queue: 1
Iterating over the queue:
3
2

As the first element to be added to the list, the output for the front element of the queue is 1, as you may have noticed.

Conclusion

In this essay, we looked at the different Java stack operations that can be applied to a queue. A list can be created, elements can be added to it, items can be removed from the front of a queue, an element can be retrieved from the front of a queue, and a queue can be iterated over. Although implementing a queue with stacks may not be as effective as doing so with a linked list, doing so can be a good practise for learning the fundamental ideas behind these data structures.

Next TopicGet Yesterday's Date from Localdate Java

← prev next →