LeetCode 844: Backspace String Compare
A clear explanation of the Backspace String Compare problem using stack simulation and an O(1) space two-pointer scan.
Tag
Stack
51 notes
LeetCode 921: Minimum Add to Make Parentheses Valid
A clear explanation of making a parentheses string valid using greedy counting.
LeetCode 907: Sum of Subarray Minimums
A clear explanation of summing subarray minimums using a monotonic stack and contribution counting.
LeetCode 901: Online Stock Span
A clear explanation of Online Stock Span using a monotonic decreasing stack with accumulated spans.
LeetCode 895: Maximum Frequency Stack
A clear explanation of designing a stack that pops the most frequent value, breaking ties by most recent insertion.
LeetCode 856: Score of Parentheses
A clear explanation of scoring a balanced parentheses string using depth counting.
LeetCode 853: Car Fleet
A clear explanation of counting car fleets by sorting cars by position and tracking arrival times.
LeetCode 946: Validate Stack Sequences
A clear explanation of solving Validate Stack Sequences by simulating stack push and pop operations.
LeetCode 772: Basic Calculator III
A clear explanation of evaluating arithmetic expressions with parentheses, precedence, and integer division.
LeetCode 770: Basic Calculator IV
A clear explanation of simplifying algebraic expressions by parsing, substituting variables, and combining polynomial terms.
LeetCode 716: Max Stack
A clear explanation of designing a stack that supports push, pop, top, peekMax, and popMax.
LeetCode 739: Daily Temperatures
Find how many days each temperature must wait for a warmer future day using a monotonic stack.
LeetCode 735: Asteroid Collision
Simulate asteroid collisions using a stack that keeps the surviving asteroids in order.
LeetCode 726: Number of Atoms
Parse a chemical formula with nested parentheses, atom names, and multipliers using recursive descent.
LeetCode 682: Baseball Game
Simulate a baseball scoring system using a stack to process operations and compute the final score.
LeetCode 678: Valid Parenthesis String
Check whether a string containing parentheses and wildcard stars can be made valid using a greedy range of possible open counts.
LeetCode 636: Exclusive Time of Functions
A stack-based solution for computing exclusive execution time from nested start and end logs.
LeetCode 232: Implement Queue using Stacks
A detailed explanation of implementing a FIFO queue using two LIFO stacks with amortized constant time operations.
LeetCode 230: Kth Smallest Element in a BST
A clear explanation of finding the kth smallest value in a binary search tree using inorder traversal.
LeetCode 227: Basic Calculator II
A detailed explanation of evaluating arithmetic expressions with stack-based parsing and operator precedence.
LeetCode 591: Tag Validator
A clear stack-based parser for validating nested XML-like tags with CDATA sections.
LeetCode 590: N-ary Tree Postorder Traversal
A clear DFS solution for returning the postorder traversal of an N-ary tree.
LeetCode 589: N-ary Tree Preorder Traversal
A clear DFS solution for returning the preorder traversal of an N-ary tree.
LeetCode 503: Next Greater Element II
A clear explanation of finding the next greater element in a circular array using a monotonic stack.
LeetCode 496: Next Greater Element I
A clear explanation of finding the next greater element using a monotonic decreasing stack and hash map.
LeetCode 484: Find Permutation
A clear explanation of constructing the lexicographically smallest permutation that matches an I and D pattern.
LeetCode 456: 132 Pattern
A clear explanation of detecting a 132 pattern using reverse traversal and a monotonic stack.
LeetCode 445: Add Two Numbers II
Add two numbers stored in forward-order linked lists using stacks and carry propagation.
LeetCode 439: Ternary Expression Parser
Evaluate a nested ternary expression using a right-to-left stack parser.
LeetCode 402: Remove K Digits
A clear explanation of the Remove K Digits problem using a greedy monotonic stack.
LeetCode 394: Decode String
A clear explanation of decoding nested repeat expressions using a stack.
LeetCode 388: Longest Absolute File Path
A clear explanation of computing the longest absolute path to a file from a serialized file system string using path lengths by depth.
LeetCode 385: Mini Parser
A clear explanation of parsing a serialized nested integer string using a stack.
LeetCode 341: Flatten Nested List Iterator
A clear explanation of Flatten Nested List Iterator using lazy stack-based flattening.
LeetCode 331: Verify Preorder Serialization of a Binary Tree
A clear explanation of verifying preorder serialization using slot counting without reconstructing the tree.
LeetCode 316: Remove Duplicate Letters
A clear explanation of Remove Duplicate Letters using a greedy monotonic stack.
LeetCode 255: Verify Preorder Sequence in Binary Search Tree
A clear explanation of the Verify Preorder Sequence in Binary Search Tree problem using a monotonic stack and lower bound tracking.
LeetCode 225: Implement Stack using Queues
A clear explanation of implementing a LIFO stack using only FIFO queue operations.
LeetCode 224: Basic Calculator
A clear explanation of evaluating an expression with plus, minus, spaces, and parentheses using a stack.
LeetCode 94: Binary Tree Inorder Traversal
A detailed guide to solving Binary Tree Inorder Traversal with recursion and an iterative stack.
LeetCode 85: Maximal Rectangle
A detailed guide to solving Maximal Rectangle by converting each matrix row into a histogram and applying a monotonic stack.
LeetCode 84: Largest Rectangle in Histogram
A detailed guide to solving Largest Rectangle in Histogram with a monotonic increasing stack.
LeetCode 173: Binary Search Tree Iterator
A clear explanation of designing an iterator over a BST using controlled inorder traversal with a stack.
LeetCode 155: Min Stack
A clear explanation of designing a stack that can return the current minimum element in constant time.
LeetCode 150: Evaluate Reverse Polish Notation
Evaluate an arithmetic expression written in Reverse Polish Notation using a stack.
LeetCode 145: Binary Tree Postorder Traversal
Return the postorder traversal of a binary tree using recursion or an iterative stack-based approach.
LeetCode 144: Binary Tree Preorder Traversal
Return the preorder traversal of a binary tree using recursion or an explicit stack.
LeetCode 71: Simplify Path
A clear guide to simplifying Unix-style file paths using a stack.
LeetCode 32: Longest Valid Parentheses
A clear explanation of finding the longest well-formed parentheses substring using a stack of indices.
LeetCode 20: Valid Parentheses
A detailed explanation of checking whether a bracket string is valid using a stack.
1.3 Stacks
Array and linked stack implementations covering push, pop, monotonic stacks, expression evaluation, and thread-safe variants.