Unit 4: Stacks and Queues

Use a stack to validate parentheses, brackets, and braces while rejecting mismatched or unfinished groups.

Process a postfix expression with numbers and operators, pushing operands and applying operations in the correct order.

Use a stack to handle precedence and grouping while converting an infix expression to postfix form.

Support push, pop, top, and getMin in constant time by tracking minimum values alongside the main stack.

Use two stacks so enqueue and dequeue behave like a FIFO queue and analyze amortized cost.

Use one or two queues so push and pop behave like a LIFO stack.

Model back and forward navigation with two stacks and explain what happens after visiting a new page.

Process path tokens, handling current directory, parent directory, and repeated separators safely.

For each value in an array, find the next value to its right that is greater.

Given daily measurements, compute how many days until a larger measurement appears.

Use a stack of increasing bar indices to compute the largest rectangle area in a histogram.

Maintain candidate indices in a deque to report the maximum value in each fixed-size window.

Process a stream of characters and report the first character that has appeared exactly once after each update.

Simulate tasks that receive fixed time slices until complete and report completion order.

Track arrivals, service durations, wait times, and maximum queue length in a service-line model.

Use a queue to visit tree nodes level by level and group values by depth.

Use a queue to find the minimum number of moves from a start cell to a target cell.

Model text editor undo and redo behavior while clearing redo history after a new edit.

Decode a compact repeated-string notation using stacks for counts and partial strings.

Given a push order and proposed pop order, simulate stack operations to determine whether the pop order is possible.

Implement enqueue and dequeue with front, size, and wraparound arithmetic.

Support insert and delete at both ends with wraparound and capacity checks.

Process a string and remove groups of k adjacent equal characters until no such group remains.

For each price, compute how many consecutive previous prices are less than or equal to it.

Compare FIFO, stack, and priority behavior for tasks with arrival times and urgency values.

Reverse only the first k items of a queue while preserving the order of the remaining items.

Given an even-length queue, interleave the first half and second half while preserving each half order.

Given function entry and exit events, determine whether the trace could come from a valid call stack.

Given several scenarios, choose stack, queue, or deque and explain how access order drives the choice.

Create an assignment with implementation, simulation, edge cases, and a written comparison of stack and queue behavior.