Linked Lists, Stacks, and Queues Questions

// Insert new_node after prev (prev != NULL)
new_node = malloc(sizeof(Node));
if (new_node == NULL) { /* handle OOM */ }

new_node->data = value;

// pointer updates
new_node->next = prev->next; // 1) point new node to successor (may be NULL)
prev->next = new_node;       // 2) link previous node to new node

// Delete node = prev->next (ensure prev and prev->next != NULL)
to_delete = prev->next;
if (to_delete == NULL) return; // nothing to delete

prev->next = to_delete->next; // 1) unlink node from list
// optional: sanitize
to_delete->next = NULL;       // 2) avoid dangling pointer
free(to_delete);              // 3) free memory

to_delete = head;
head = head->next;
to_delete->next = NULL;
free(to_delete);

public class SinglyLinkedList<T> {
    private static class Node<T> {
        T value;
        Node<T> next;
        Node(T val) { value = val; }
    }

    private Node<T> head;
    private int size = 0;

    // Insert new value at the head of the list
    public void insertAtHead(T value) {
        Node<T> node = new Node<>(value);
        node.next = head;    // works when head is null (empty list) too
        head = node;
        size++;
    }

    public int size() { return size; }

    // Print nodes in order from head to tail like: [a -> b -> c]
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        Node<T> curr = head;
        while (curr != null) {
            sb.append(curr.value);
            if (curr.next != null) sb.append(" -> ");
            curr = curr.next;
        }
        sb.append(']');
        return sb.toString();
    }
}

import re

class EvalError(Exception):
    pass

def precedence(op):
    return {'+':1, '-':1, '*':2, '/':2}.get(op, 0)

def apply_op(a, b, op):
    if op == '+': return a + b
    if op == '-': return a - b
    if op == '*': return a * b
    if op == '/':
        if b == 0: raise EvalError("Division by zero")
        return int(a / b)  # truncate toward zero
    raise EvalError(f"Unknown operator {op}")

def evaluate(expr):
    # Tokenize: integers, operators, parens. Skip spaces.
    tokens = re.findall(r'\d+|[()+\-*/]', expr.replace(' ', ''))
    if not tokens:
        raise EvalError("Empty expression")

    values = []     # operand stack
    ops = []        # operator stack

    def pop_apply():
        if len(values) < 2 or not ops:
            raise EvalError("Malformed expression")
        b = values.pop()
        a = values.pop()
        values.append(apply_op(a, b, ops.pop()))

    i = 0
    while i < len(tokens):
        tok = tokens[i]
        if re.fullmatch(r'\d+', tok):
            values.append(int(tok))
        elif tok == '(':
            ops.append(tok)
        elif tok == ')':
            while ops and ops[-1] != '(':
                pop_apply()
            if not ops or ops[-1] != '(':
                raise EvalError("Mismatched parenthesis")
            ops.pop()
        else:  # operator + - * /
            # determine unary: if at start or after '(' or another operator
            is_unary = (i == 0) or (tokens[i-1] in '()+-*/')
            if is_unary:
                # unary + is no-op; unary - is multiply by -1
                if tok == '+':
                    # skip unary plus
                    i += 1
                    continue
                elif tok == '-':
                    # treat unary minus as (0 - nextValue)
                    values.append(0)
                else:
                    raise EvalError("Unsupported unary operator")
            # handle precedence and left-associativity
            while ops and ops[-1] != '(' and precedence(ops[-1]) >= precedence(tok):
                pop_apply()
            ops.append(tok)
        i += 1

    while ops:
        if ops[-1] == '(' or ops[-1] == ')':
            raise EvalError("Mismatched parenthesis")
        pop_apply()

    if len(values) != 1:
        raise EvalError("Malformed expression")
    return values[0]

# Example:
# print(evaluate(" -3 + 2 * (1 + 5) / 3 "))  -> -3 + 2*(6)/3 = -3 + 4 = 1

import java.util.concurrent.locks.*;
import java.util.Arrays;

public class BoundedBlockingQueue<T> {
    private final T[] items;
    private int head = 0, tail = 0, count = 0;
    private final ReentrantLock lock;
    private final Condition notEmpty;
    private final Condition notFull;

    @SuppressWarnings("unchecked")
    public BoundedBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0) throw new IllegalArgumentException();
        items = (T[]) new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull = lock.newCondition();
    }

    // Blocks if full; responds to interruption by throwing InterruptedException
    public void enqueue(T item) throws InterruptedException {
        if (item == null) throw new NullPointerException();
        lock.lockInterruptibly();
        try {
            while (count == items.length) {
                notFull.await(); // releases lock and waits
            }
            items[tail] = item;
            tail = (tail + 1) % items.length;
            count++;
            notEmpty.signal(); // wake one waiting consumer
        } finally {
            lock.unlock();
        }
    }

    // Blocks if empty; responds to interruption by throwing InterruptedException
    public T dequeue() throws InterruptedException {
        lock.lockInterruptibly();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            T item = items[head];
            items[head] = null; // help GC
            head = (head + 1) % items.length;
            count--;
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        lock.lock();
        try { return count; } finally { lock.unlock(); }
    }
}

import java.util.*;

public class RpnEvaluator {
    public static int evalRPN(String[] tokens) {
        if (tokens == null || tokens.length == 0) {
            throw new IllegalArgumentException("Empty token list");
        }

        Deque<Integer> stack = new ArrayDeque<>();
        Set<String> ops = Set.of("+", "-", "*", "/");

        for (String t : tokens) {
            if (ops.contains(t)) {
                if (stack.size() < 2) {
                    throw new IllegalArgumentException("Malformed expression: insufficient operands for operator " + t);
                }
                int b = stack.pop(); // right operand
                int a = stack.pop(); // left operand
                int res;
                switch (t) {
                    case "+": res = a + b; break;
                    case "-": res = a - b; break;
                    case "*": res = a * b; break;
                    case "/":
                        if (b == 0) throw new IllegalArgumentException("Division by zero");
                        res = a / b; // Java int division truncates toward zero
                        break;
                    default: throw new IllegalArgumentException("Unsupported operator: " + t);
                }
                stack.push(res);
            } else {
                try {
                    stack.push(Integer.parseInt(t));
                } catch (NumberFormatException e) {
                    throw new IllegalArgumentException("Invalid token: " + t, e);
                }
            }
        }

        if (stack.size() != 1) {
            throw new IllegalArgumentException("Malformed expression: leftover operands");
        }
        return stack.pop();
    }

    // simple test
    public static void main(String[] args) {
        String[] tokens = {"2","1","+","3","*"};
        System.out.println(evalRPN(tokens)); // prints 9
    }
}