Stack (LIFO)

# Python list as stack
stack = []
stack.append(10)     # push — O(1)
stack.append(20)
stack.append(30)
top = stack[-1]      # peek — O(1) → 30
val = stack.pop()    # pop  — O(1) → 30

# Balanced parentheses
def is_valid(s):
    st = []
    for c in s:
        if c == '(': st.append(c)
        elif st: st.pop()
        else: return False
    return not st

// Array as stack
const stack = [];
stack.push(10);     // push — O(1)
stack.push(20);
stack.push(30);
const top = stack[stack.length - 1]; // peek — O(1) → 30
const val = stack.pop();             // pop  — O(1) → 30

// Balanced parentheses
function isValid(s) {
  const st = [];
  for (const c of s) {
    if (c === '(') st.push(c);
    else if (st.length) st.pop();
    else return false;
  }
  return st.length === 0;
}

// ArrayDeque as stack (preferred over legacy Stack)
Deque<Integer> stack = new ArrayDeque<>();
stack.push(10);      // push — O(1)
stack.push(20);
stack.push(30);
int top = stack.peek();  // peek — O(1) → 30
int val = stack.pop();   // pop  — O(1) → 30

// Balanced parentheses
boolean isValid(String s) {
    Deque<Character> st = new ArrayDeque<>();
    for (char c : s.toCharArray()) {
        if (c == '(') st.push(c);
        else if (!st.isEmpty()) st.pop();
        else return false;
    }
    return st.isEmpty();
}

#include <stack>

std::stack<int> st;
st.push(10);          // push — O(1)
st.push(20);
st.push(30);
int top = st.top();   // peek — O(1) → 30
st.pop();             // pop  — O(1)

// Balanced parentheses
bool is_valid(const std::string& s) {
    std::stack<char> st;
    for (char c : s) {
        if (c == '(') st.push(c);
        else if (!st.empty()) st.pop();
        else return false;
    }
    return st.empty();
}