DSA Topics

The first five minutes of a coding interview decide the rest of it. A repeatable routine for parsing a problem, finding the constraints, working examples by hand, and identifying the pattern before you write any code.

Estimate time and space complexity in seconds, and use the input constraints to work out the target complexity before you have thought of an algorithm. The fastest way to know your idea is wrong.

Nested loops, index arithmetic, and loop invariants — taught through star patterns and pyramids. This is the skill that later makes tree traversal, two pointers, and DP tables feel obvious instead of impossible.

Recursion is a function that pauses itself. Learn to draw the call stack and the call tree, and to answer the one question that unlocks nearly every tree problem: what does this call return to its parent?

What a vector, an array, a hash map and a string actually are in memory, and how C++ and JavaScript differ. Knowing this is why "just use a hash map" stops being a magic phrase and starts being a trade you can price.

What an array actually is in memory, why appending is amortised O(1) but inserting is O(n), and the handful of signals that tell you the answer is a single pass rather than a nested loop.

Strings are arrays of characters with one crucial difference between C++ and JavaScript — mutability. Frequency counting, character arithmetic, and the building trap that turns an O(n) loop into O(n squared).

The single highest-leverage data structure in interviews. What a hash map costs, why it turns O(n squared) scans into O(n) passes, and the exact phrases in a problem statement that should make you reach for one.

Learn what a stack stores, why last-in-first-out order models nested work, and how push, pop, and top power parsing, undo, recursion, and monotonic-stack interview problems in C++ and JavaScript.

Understand first-in-first-out queues and double-ended queues, their C++ and JavaScript implementations, and why BFS, level-order traversal, scheduling, and sliding-window algorithms depend on processing items in arrival order.

Learn singly and doubly linked lists as nodes connected by references, with pointer-safe traversal, dummy heads, insertion and deletion costs, C++ and JavaScript node models, and interactive link diagrams.

Two indices walking a sorted array from opposite ends, discarding half the remaining possibilities at every step. The template is four lines — the part worth learning is the argument for why discarding is safe.

Count first, then answer the question. The pattern behind anagrams, duplicates, top-k, and grouping — plus when a 26-slot array beats a hash map and when a canonical key beats both.

When the window size never changes there is no shrink loop — one element enters and one leaves on every step. The simpler half of the sliding window family, and the right place to start.

Expand right always, shrink left while invalid, record when valid. One template covers longest-substring, character replacement, and minimum window — the only thing that changes is the definition of invalid.

Precompute running totals so any range sum becomes one subtraction. The pattern that answers many range queries in O(1) each, and the one that rescues subarray problems when negative numbers break the sliding window.

Recognize next-greater, next-smaller, span, and histogram problems; learn the increasing and decreasing stack invariants; and understand why nested pop loops still run in O(n) across the full algorithm.

Learn binary search through interval invariants, exact lookup and boundary templates, overflow-safe midpoint calculation, rotated arrays, virtual indexing, and common off-by-one failures in C++ and JavaScript.

Turn optimization problems into monotone feasibility checks, choose safe numeric bounds, and find the minimum feasible or maximum feasible answer with reusable C++ and JavaScript binary-search templates.

Learn when sorting is the optimization, what ordering buys, stable versus unstable behavior, numeric and custom comparators in C++ and JavaScript, and the strict-order rules that prevent subtle interview bugs.

Learn the O(n), O(1)-space index-placement pattern for arrays containing values from 1 through n, including missing and duplicate variants, loop invariants, safe swaps, and C++ plus JavaScript templates.

Master Floyd's fast-and-slow pointer pattern for cycle detection, cycle entrances, linked-list middles, and fixed gaps from the end, with proofs, C++ and JavaScript templates, and step-by-step traces.

Learn the prev-curr-next reversal invariant for whole lists, sublists, and fixed-size groups, including safe pointer ordering, reconnection rules, C++ and JavaScript templates, and interactive link traces.