Medium
🔍 Searching
Binary Search
The foundation of database indices. Watch how aggressively O(log n) searches eliminate half the problem at every step, requiring sorted inputs first.
Time: O(log n)
Space: O(1)
12 min
000
PyAnimateIntermediate
Intermediate
All tracks
Track
Intermediate
Builders shipping scripts and apps
Upgrade your toolkit. We'll dive into dictionaries, stacks, queues, and classic searches. These are the daily drivers you'll use in every backend you ever build.
Data structures
Searching algorithms
OOP foundations
10 algorithms in this track
Start
Medium
🔀 Sorting
Selection Sort
Scan for the absolute minimum, then anchor it at the front. It guarantees exactly n-1 swaps—useful in systems where writing data is much costlier than reading it.
Time: O(n²)
Space: O(1)
12 min
000
Medium
🔀 Sorting
Insertion Sort
Slide elements left until they hit order. It's actually incredibly fast for naturally 'nearly sorted' data, which happens in the real world constantly.
Time: O(n²) worst, O(n) best
Space: O(1)
12 min
000
Medium
Array
Two Pointers
Converging indices. See how marching a left and right pointer can elegantly solve array problems in O(n) time, bypassing the classic O(n²) double loop.
Time: O(n)
Space: O(1)
10 min
000
Medium
Hash Maps
Hash Map Counting
The O(1) dictionary trick. This is the bedrock for counting frequencies—an essential pattern when you're querying fast instead of looping slow.
Time: O(n)
Space: O(k)
10 min
000
Medium
📦 Data Structures
Stack Operations
Last In, First Out (LIFO). Push, pop, and peek your way to understanding how undo-trees, browser histories, and function call stacks actually operate.
Time: O(1) per op
Space: O(n)
10 min
000
Medium
📦 Data Structures
Queue Operations
First In, First Out (FIFO). Tasks in, tasks out. This animates the core mechanism behind task workers, event loops, and rate limiters.
Time: O(1) per op
Space: O(n)
8 min
000
Medium
Strings
Anagram Check
Are these strings just scrambled? Watch how mapping character frequencies in a dictionary solves this gracefully without the overhead of sorting strings.
Time: O(n)
Space: O(k) — k = unique chars
8 min
000
Medium
Array
Sliding Window Max Sum
Gliding a fixed frame over an array. See how it subtracts the outgoing element and adds the incoming one, saving you from disastrous O(n*k) recalculations.
Time: O(n)
Space: O(1)
8 min
000
Medium
🔀 Sorting
Merge Sorted Arrays
Zipper two sorted arrays together. This is the cornerstone sub-routine that powers the beast that is Merge Sort.
Time: O(m + n)
Space: O(m + n)
8 min
000