Data Structures & Algorithms

How does the algorithm scale as data grows?

How much RAM does your algorithm eat?

The absolute worst-case scenario.

The Best Case and the Exact Case.

Averaging out the occasional massive spike.

The foundational building block of computer science.

Squeezing the array from both ends.

Analyzing a continuous chunk of data.

Instantly querying a range.

Looking backwards.

Applying massive updates instantly.

The maximum subarray sum.

Combining overlapping timeframes.

Sorting in O(N) without extra space.

Arrays in disguise.

Slicing and dicing text.

Tallying the characters.

Reading the same forwards and backwards.

Same letters, different order.

Finding a needle in a haystack.

The most famous Sliding Window problem.

Parsing strings systematically.

The O(1) magic box.

Key-Value pairs.

Unique items only.

Counting the occurrences.

The most famous interview question in the world.

When the math fails.

Connecting nodes across fragmented memory.

Walking backwards.

The most famous pointer manipulation problem.

Floyd's Cycle-Finding Algorithm.

Finding infinite loops.

Zipping two sorted lists together.

Deleting from the back in a forward-only list.

When two paths converge.

LIFO: Last In, First Out.

FIFO: First In, First Out.

The best of both worlds.

Finding the Next Greater Element.

Sliding Window Maximum.

Retrieving the minimum in O(1) time.

Inverting the flow of data.

Functions calling themselves.

How the CPU handles recursion.

When to stop digging.

Hacking the Call Stack.

Exploring all possibilities.

Rearranging the order.

To include, or not to include.

Subsets with a fixed length.

Branching data structures.

How to visit every node.

Node -> Left -> Right

Left -> Node -> Right

Left -> Right -> Node

Scanning horizontally.

The O(log N) lookup machine.

Searching, inserting, and deleting.

Preventing the straight-line degenerate tree.

Measuring the geometry of the tree.

Finding the junction point.

Flattening the tree to a string.

The autocomplete engine.

The fast-track to the extreme.

Bubbling up and sinking down.

The absolute largest.

Line cutting allowed.

O(N) magical sorting.

The ultimate Heap interview pattern.

QuickSelect vs Heap.

The ultimate tournament bracket.

Nodes and Edges.

The gold standard for graph representation.

The massive 2D grid.

Plunging down the rabbit hole.

The shortest path.

The 2D Grid Implicit Graph.

The Deep Copy.

Detecting Deadlocks.

Kahn's Algorithm.

The shortest path on a weighted graph.

Handling negative weights.

All-Pairs Shortest Path.

Prim's and Kruskal's Algorithms.

The Cycle Detector.

O(log N) magic on sorted data.

Finding where it belongs.

Finding the boundary.

Navigating the pivot.

Finding the pivot.

Flattening the grid.

Bringing order to chaos.

Bubbling the largest to the top.

Selecting the smallest.

Sorting a deck of cards.

Divide and Conquer.

The fast, chaotic pivot.

Breaking the N log N barrier.

Sorting by digits.

Sorting decimals.

Take what you can get.

Can you reach the end?

The minimum jumps.

The circular journey.

Sorting and organizing.

Max math.

Finding the boundaries.

Those who cannot remember the past...

Caching the recursive tree.

Building from the ground up.

Fibonacci in disguise.

Paying the toll.

To rob, or not to rob.

The classic Unbounded Knapsack.

Finding the hidden sequence.

The 2D Matrix.

Slicing the dictionary.

The 0/1 Choice.

Navigating the grid.

Speaking the machine's language.

The Logical Gates.

Sliding the columns.

Hamming Weight.

DP meets Bits.

The XOR cancellation trick.

Flipping the mirror.

The lone survivor.

The universal language.

The Sieve of Eratosthenes.

The Euclidean Algorithm.

Clock math.

Binary Exponentiation.

Counting the fives.

The Greedy Subtraction.

The classic.

Least Recently Used.

Without Repeating Characters.

The LIFO Stack.

The Priority Queue.

The two pointers.

The dual heaps.

The BFS short path.

Parsing the math.

Kadane's Algorithm.

Buy low, sell high.

The prefix and suffix.