Stacks — LIFO and Real-World Uses

class Stack {
    private List<Integer> data;
 
    public Stack() {
        data = new ArrayList<>();
    }
 
    public void push(int val) {
        data.add(val);             // O(1)
    }
 
    public int pop() {
        return data.remove(data.size() - 1); // O(1)
    }
 
    public int peek() {
        return data.get(data.size() - 1);    // O(1) — look without removing
    }
 
    public boolean isEmpty() {
        return data.isEmpty();
    }
 
    public int size() {
        return data.size();
    }
}

public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char ch : s.toCharArray()) {
        if (ch == '(' || ch == '{' || ch == '[') {
            stack.push(ch);
        } else if (ch == ')' || ch == '}' || ch == ']') {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if ((ch == ')' &&

public int evalRPN(String[] tokens) {
    Stack<Integer> stack = new Stack<>();
    for (String token : tokens) {
        if ("+-*/".contains(token)) {
            int b = stack.pop();
            int a = stack.pop();
            switch (token) {
                case "+": stack.push(a + b); break;
                case "-": stack.push(a - b); break;
                case "*": stack.push(a * b); break

public int[] nextGreater(int[] arr) {
    int[] result = new int[arr.length];
    Arrays.fill(result, -1);
    Stack<Integer> stack = new Stack<>(); // stores indices
 
    for (int i = 0; i < arr.length; i++) {
        while (!stack.isEmpty() && arr[stack.peek()] < arr[i]) {
            int idx = stack.pop();
            result[idx] = arr[i]; // arr[i] is the next greater for idx
        }
        stack.push(i);

class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack; // tracks minimums
 
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
 
    public void push(int val) {
        stack.push(val);
        int minVal = minStack.isEmpty() ? val : Math.min(val, minStack.peek());
        minStack.push(minVal);
    }
 
    public void pop() {
        stack.