Stacks and Queues

In the world of data structures, stacks and queues are two fundamental concepts that are widely used to store and access data. Both stacks and queues follow the principle of First-In-First-Out (FIFO) or Last-In-First-Out (LIFO) ordering.

Stacks

A stack is a data structure that follows the LIFO ordering, meaning that the most recently added element is the first one to be removed. Think of a stack of plates, where you can only add or remove plates from the top. The operations supported by a stack are:

• push: Add an element to the top.
• pop: Remove and return the top element.
• peek: Return the top element without removing it.

Here's an example of creating a stack, pushing elements into it, and popping and peeking elements from it in Java:

1import java.util.Stack;
2
3class Main {
4  public static void main(String[] args) {
5    // Create a stack
6    Stack<String> stack = new Stack<String>();
7
8    // Push elements into the stack
9    stack.push("element1");
10    stack.push("element2");
11    stack.push("element3");
12
13    // Pop elements from the stack
14    String poppedElement = stack.pop();
15
16    // Print the popped element
17    System.out.println("Popped Element: " + poppedElement);
18
19    // Get the top element of the stack
20    String topElement = stack.peek();
21
22    // Print the top element
23    System.out.println("Top Element: " + topElement);
24  }
25}

Queues

A queue is a data structure that follows the FIFO ordering, meaning that the element that has been in the queue the longest is the first one to be removed. Think of a queue of people waiting in a line, where the person who has been waiting the longest gets served first. The operations supported by a queue are:

• enqueue: Add an element to the end.
• dequeue: Remove and return the first element.
• peek: Return the first element without removing it.

Here's an example of creating a queue, enqueueing elements into it, and dequeuing and peeking elements from it in Java:

1import java.util.LinkedList;
2import java.util.Queue;
3
4class Main {
5  public static void main(String[] args) {
6    // Create a queue
7    Queue<String> queue = new LinkedList<String>();
8
9    // Enqueue elements into the queue
10    queue.add("element1");
11    queue.add("element2");
12    queue.add("element3");
13
14    // Dequeue elements from the queue
15    String dequeuedElement = queue.remove();
16
17    // Print the dequeued element
18    System.out.println("Dequeued Element: " + dequeuedElement);
19
20    // Get the first element of the queue
21    String firstElement = queue.peek();
22
23    // Print the first element
24    System.out.println("First Element: " + firstElement);
25  }
26}

Understanding the concepts of stacks and queues and their respective applications is crucial in developing efficient algorithms and solving various problems.

xxxxxxxxxx

class Main {

  public static void main(String[] args) {

    // Create a stack

    Stack<String> stack = new Stack<String>();

​

    // Push elements into the stack

    stack.push("element1");

    stack.push("element2");

    stack.push("element3");

​

    // Pop elements from the stack

    String poppedElement = stack.pop();

​

    // Print the popped element

    System.out.println("Popped Element: " + poppedElement);

​

    // Get the top element of the stack

    String topElement = stack.peek();

​

    // Print the top element

    System.out.println("Top Element: " + topElement);

  }

}