Stack & Queue

Keep a parallel min stack whose top is always the current minimum, so getMin is constant time.

Push every opener, pop and type-match on every closer, and the string is valid only if the stack ends empty.

Add an opener while openers remain; add a closer only while closers placed are fewer than openers placed; record when both counts reach n.

Push every opener, and on every closer pop the top and check it matches; valid only if the stack ends empty.

Open while open < n, close while close < open, record at length 2n; never generate an invalid string.

Push numbers, and on each operator pop two operands, compute, and push the result back; the last value on the stack is the answer.

Push to an inbox stack, pour into an outbox stack only when the outbox is empty, and each element moves once for amortized constant time.

Two stacks make a queue by reversing order on lazy transfer; a queue makes a stack by rotating the newest element to the front on every push.

Keep a second stack whose top always holds the minimum so far, pushing and popping it in lockstep with the main stack.

A queue is a fair waiting line where the first one in is the first one out.

Keep a parallel min stack whose top always holds the minimum of everything currently in the main stack.

Use an inbox stack for pushes and an outbox stack for pops; flip the inbox into the outbox only when the outbox is empty for amortized O(1).

A stack is Last In First Out: you only add and remove from the top, like a pile of plates.

Backtrack placing an open while opens are below N, and a close only while closes trail opens, recording at length 2N.

Push indices on a decreasing stack; when a warmer day comes, pop each colder index and record current minus popped as the wait.

Keep an increasing stack of indices; when a shorter bar arrives, pop each taller bar and compute its rectangle using the width between the new top and the current index.

Use a queue and snapshot its size at each step to process exactly one full level before moving down.

Preorder is node-left-right, inorder is left-node-right, postorder is left-right-node; iterative versions replace recursion with an explicit stack.

Push every opener, and on every closer pop the top and check it matches; the string is valid only if the stack ends empty.

Push indices with a base marker of -1, and on each closer pop and measure the valid run length back to the new stack top.