Data Structures & Algorithms

The smallest idea in all of code: a labeled box that holds one value — and that value can change.

Before any algorithm: an array is a row of numbered boxes. Meet the index and the value.

Why searching is even a problem: a computer can't see all the boxes at once — it opens them one by one.

Numbers are secretly rows of on/off light switches — and flipping them lets you do clever tricks like erasing duplicates with XOR.

Check each element one by one until you find the target. The O(n) baseline.

'Sorted' isn't just 'tidy' — it's a promise: each box is never smaller than the one before it.

Find a target in a sorted array by repeatedly halving the search space.

Find a pair summing to a target in a sorted array by converging two pointers.

Glide a contiguous window across an array or string, updating the answer as it moves — one pass instead of re-checking every range.

Precompute running totals once, then answer any range-sum in O(1) with a single subtraction.

Store values in buckets by value % size for O(1) average lookup.

Store key→value pairs and fetch any of them almost instantly — by letting a hash function pick the slot.

LIFO vs FIFO: a stack pops the newest, a queue dequeues the oldest.

Keep a stack that stays sorted in one direction to find each number's next-greater element in a single O(n) pass.

Follow next pointers from head to null — a pointer is a reference to a node.

Find a pattern inside a text without ever re-checking characters you already matched, using the LPS table.

Pick the most non-overlapping activities by sorting on END time and always grabbing the next one that fits.

Sort by repeatedly swapping adjacent out-of-order pairs until settled.

Grow a sorted prefix by inserting each next element into its correct spot.

Divide the array in half, sort each half, then merge them. O(n log n).

Pick a pivot, push smaller values left and bigger ones right, then repeat on each side. O(n log n) on average.

See recursion as a call stack: calls push on the way down, pop on the way up.

Explore choices as a decision tree — make a choice, recurse, then UNDO it and try the next one.

Count ways to climb n stairs (1 or 2 at a time) by filling a DP table.

Count right/down paths across a grid — the clearest 2D DP, where the table IS the map.

Fewest coins to make an amount by building up a best-answer table, one amount at a time.

Find the longest run of increasing numbers (not necessarily next to each other) with a dp[] table.

Pack a weight-limited bag for maximum value by filling a 2D best-value table.

Fewest insert/delete/replace edits to turn one word into another — the classic 2D string DP.

In-order traversal of a BST (left → node → right) visits values in sorted order.

A tree of letters where words that start the same share the same path — the magic behind autocomplete.

Keep left < node < right at every node, and searching becomes one walk straight down — binary search on a tree.

A BST can grow into a lopsided line. A B-tree stays short by SPLITTING: when a node overfills, its middle key jumps up. Watch it stay balanced.

Store the sum of every range in a tree so a range-sum query reads a few nodes (O(log n)) instead of adding every element.

A tree that always keeps the smallest (or largest) on top — and secretly lives in a plain array.

Build a max-heap, then keep pulling the biggest off the top and parking it at the end. Guaranteed O(n log n), in place.

A tiny structure that answers 'are these two things connected?' almost instantly — the heart of network and MST algorithms.

A graph is dots and lines — but a computer stores it as numbers. See the picture, the matrix, and the list as the same graph.

Explore a graph level by level using a queue — nearest nodes first.

Explore a graph by going deep down one path before backtracking.

Order tasks so every prerequisite comes before the task that needs it — using DFS on a directed graph.

Find the cheapest route through a weighted graph by always finalizing the closest node next.

Find shortest paths even with NEGATIVE roads by relaxing every edge V-1 times.

Find the cheapest cost between EVERY pair of towns by filling a distance matrix with a triple loop.

Connect every town with the cheapest total road and no loops by adding edges cheapest-first.

How the internet picks a route: the fastest path, not the fewest hops. Watch routers find the lowest-latency way across a mesh.