Implementing Stack Data Structure

Stack: [10, 20, 30, 40]  (Top = 40)
Peek() → Returns 40
Stack remains unchanged.

Stack: [10, 20, 30]  
IsEmpty() → Returns False

Stack: []  
IsEmpty() → Returns True

// Stack implementation using an array
class Solution {

  private int[] stack;
  private int top;
  private int capacity;

  // Constructor to initialize stack
  public Solution(int capacity) {
    this.capacity = capacity;
    stack = new int[capacity];
    top = -1; // Stack is initially empty
  }

  // Push operation
  public void push(int value) {
    if (top == capacity - 1) {
      System.out.println("Stack Overflow! Cannot push " + value);
      return;
    }
    stack[++top] = value;
    System.out.println(value + " pushed to stack.");
  }

  // Pop operation
  public int pop() {
    if (isEmpty()) {
      System.out.println("Stack Underflow! No elements to pop.");
      return -1; // Return -1 to indicate error
    }
    return stack[top--];
  }

  // Peek operation
  public int peek() {
    if (isEmpty()) {
      System.out.println("Stack is empty!");
      return -1;
    }
    return stack[top];
  }

  // Check if the stack is empty
  public boolean isEmpty() {
    return top == -1;
  }

  // Main method to demonstrate stack operations
  public static void main(String[] args) {
    Solution stack = new Solution(5);

    stack.push(10);
    stack.push(20);
    stack.push(30);
    System.out.println("Top element: " + stack.peek()); // Output: 30

    System.out.println("Popped: " + stack.pop()); // Output: 30
    System.out.println("Popped: " + stack.pop()); // Output: 20

    System.out.println("Is stack empty? " + stack.isEmpty()); // Output: false
    stack.pop(); // Popping last element
    System.out.println("Is stack empty? " + stack.isEmpty()); // Output: true
  }
}

// Stack implementation using a linked list

// class ListNode {
//     int val;
//     ListNode next;
//     ListNode(int x) { val = x; }
// }

class Solution {

  private ListNode top; // Top of the stack

  // Constructor
  public Solution() {
    this.top = null;
  }

  // Push operation
  public void push(int value) {
    ListNode newNode = new ListNode(value);
    newNode.next = top;
    top = newNode;
    System.out.println(value + " pushed to stack.");
  }

  // Pop operation
  public int pop() {
    if (isEmpty()) {
      System.out.println("Stack Underflow! No elements to pop.");
      return -1;
    }
    int poppedValue = top.val;
    top = top.next;
    return poppedValue;
  }

  // Peek operation
  public int peek() {
    if (isEmpty()) {
      System.out.println("Stack is empty!");
      return -1;
    }
    return top.val;
  }

  // Check if the stack is empty
  public boolean isEmpty() {
    return top == null;
  }

  // Main method to demonstrate stack operations
  public static void main(String[] args) {
    Solution stack = new Solution();

    stack.push(10);
    stack.push(20);
    stack.push(30);
    System.out.println("Top element: " + stack.peek()); // Output: 30

    System.out.println("Popped: " + stack.pop()); // Output: 30
    System.out.println("Popped: " + stack.pop()); // Output: 20

    System.out.println("Is stack empty? " + stack.isEmpty()); // Output: false
    stack.pop(); // Popping last element
    System.out.println("Is stack empty? " + stack.isEmpty()); // Output: true
  }
}

I just read a lesson on **Implementing Stack Data Structure** (DSA) and want to truly understand it. Explain Implementing Stack Data Structure from first principles using ONE vivid real-world analogy and a visual mental model — draw it as ASCII art or a clear step-by-step diagram — with a concrete example using real numbers. Then ask me one question to check I got the mental picture, and wait for my reply. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Teach me **Implementing Stack Data Structure** interactively. Ask me ONE guiding question at a time, wait for my answer, and adapt to my confusion — build the idea with me step by step instead of explaining it all at once. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Quiz me on **Implementing Stack Data Structure** with 5 questions, easy to tricky, ONE at a time. Tell me if each answer is right; at the end, explain clearly what I got wrong and why. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

Help me remember **Implementing Stack Data Structure** for the long term: give the one-sentence intuition, a memorable hook/mnemonic, a tiny worked example, and 3 active-recall flashcards (Q -> A). If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.