Stacks & Queues

// ✅ PREFERRED — ArrayDeque used as a stack
Deque<Integer> stack = new ArrayDeque<>();

stack.push(10);          // addFirst(10) — add to top
stack.push(20);
stack.push(30);

stack.peek();            // 30 — read top, do NOT remove
stack.pop();             // 30 — removes and returns top
stack.isEmpty();         // false
stack.size();            // 2

// ❌ AVOID in interviews — legacy, synchronized
Stack<Integer> legacyStack = new Stack<>();
legacyStack.push(10);   // works, but prefer Deque

// Push: addFirst / push / offerFirst
stack.push(x);          // throws if capacity exceeded (rare)
stack.offerFirst(x);    // returns false if capacity exceeded

// Pop: removeFirst / pop / pollFirst
stack.pop();             // throws NoSuchElementException if empty
stack.pollFirst();       // returns null if empty — safer for conditionals

// Peek: peekFirst / peek / getFirst
stack.peek();            // null if empty
stack.getFirst();        // throws if empty

// Check
stack.isEmpty();
stack.size();

// ⚠️ Common interview pattern — check before pop:
if (!stack.isEmpty() && stack.peek() < threshold)
    stack.pop();

public int[] nextGreaterElement(int[] nums) {
    int[] ans = new int[nums.length];
    Arrays.fill(ans, -1);                    // default: no greater element
    Deque<Integer> stack = new ArrayDeque<>(); // stores INDICES

    for (int i = 0; i < nums.length; i++) {
        // Pop all indices whose element is smaller than current
        while (!stack.isEmpty() && nums[stack.peek()] < nums[i]) {
            ans[stack.pop()] = nums[i]; // current is the NGE for popped index
        }
        stack.push(i);
    }
    return ans;
}
// Time: O(N) — each element pushed/popped at most once
// Space: O(N) — stack in worst case

public int largestRectangleArea(int[] heights) {
    Deque<Integer> stack = new ArrayDeque<>(); // indices, increasing heights
    int maxArea = 0, n = heights.length;

    for (int i = 0; i <= n; i++) {
        // Use 0 as sentinel at end to flush all remaining bars
        int curH = (i == n) ? 0 : heights[i];
        while (!stack.isEmpty() && curH < heights[stack.peek()]) {
            int h = heights[stack.pop()];          // height of this bar
            int w = stack.isEmpty() ? i : i - stack.peek() - 1; // width
            maxArea = Math.max(maxArea, h * w);
        }
        stack.push(i);
    }
    return maxArea;
}
// [2,1,5,6,2,3]:
// i=0: push 0. stack=[0]
// i=1: h[1]=1 < h[0]=2 → pop 0, h=2, w=1(stack empty), area=2
//      push 1. stack=[1]
// i=2,3: increasing → push. stack=[1,2,3]
// i=4: h=2 < h[3]=6 → pop 3, h=6,w=4-2-1=1, area=6
//      2 < h[2]=5 → pop 2, h=5,w=4-1-1=2, area=10 ← max!
// ... continues. Final maxArea = 10 ✓

// ArrayDeque used as a QUEUE — add at tail, remove from head
Queue<Integer> queue = new ArrayDeque<>();

queue.offer(1);         // enqueue to tail
queue.offer(2);
queue.offer(3);
                         // queue: [1, 2, 3]  (1 is head)
queue.peek();           // → 1  (read head, no remove)
queue.poll();           // → 1  (remove head)
queue.peek();           // → 2
queue.size();           // → 2
queue.isEmpty();        // → false

// BFS template — bread-and-butter queue usage:
while (!queue.isEmpty()) {
    int node = queue.poll();
    // process node
    // add neighbours: queue.offer(neighbour)
}

public int[] maxSlidingWindow(int[] nums, int k) {
    int[] res = new int[nums.length - k + 1];
    Deque<Integer> dq = new ArrayDeque<>(); // stores indices, decreasing values

    for (int i = 0; i < nums.length; i++) {
        // 1. Remove indices outside the current window
        if (!dq.isEmpty() && dq.peekFirst() < i - k + 1)
            dq.pollFirst();

        // 2. Remove indices with smaller values (they can never be max)
        while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i])
            dq.pollLast();

        dq.offerLast(i);

        // 3. Window is full — record the max (front of deque)
        if (i >= k - 1) res[i - k + 1] = nums[dq.peekFirst()];
    }
    return res;
}
// Each element enters and leaves the deque at most once → O(N) total

public int evalRPN(String[] tokens) {
    Deque<Integer> stack = new ArrayDeque<>();
    for (String t : tokens) {
        if ("+-*/".contains(t)) {
            int b = stack.pop(), a = stack.pop(); // order matters!
            switch (t) {
                case "+": stack.push(a + b); break;
                case "-": stack.push(a - b); break;
                case "*": stack.push(a * b); break;
                case "/": stack.push(a / b); break; // truncates toward zero
            }
        } else {
            stack.push(Integer.parseInt(t));
        }
    }
    return stack.pop();
}