Data Structures & Algorithms
Arrays, hash tables, trees, graphs, recursion and the patterns built on top of them, explained with everyday examples before any notation appears.
Lessons in order
- 01Beginner 14 min
Big O — Measuring How Code Scales
Learn how to judge whether code will still be fast with a million items, using everyday comparisons before any notation appears.
- 02Beginner 13 min
Arrays — Direct Access by Position
Why reading item 500 is instant but inserting at the front is slow, and what that means for the code you write every day.
- 03Beginner 13 min
Strings — Text as a Data Structure
Why string concatenation in a loop is slow, how to compare and search text efficiently, and the patterns that solve most string problems.
- 04Beginner 14 min
Linked Lists — Items That Point to the Next
How linked lists differ from arrays, why insertion is cheap and lookup is not, and where this structure genuinely earns its place.
- 05Beginner 12 min
Stack — Last In, First Out
The structure behind undo buttons, bracket matching and the call stack itself. Learn push, pop and where stacks quietly appear.
- 06Beginner 12 min
Queue — First In, First Out
The structure behind job processing, print queues and breadth-first search. Learn enqueue, dequeue and why a plain list is the wrong choice.
- 07Beginner 14 min
Hash Tables — Instant Lookup by Key
How hashing turns a key into a location, why lookups stay fast as data grows, what a collision is, and when hashing goes wrong.
- 08Beginner 14 min
Recursion — A Function That Calls Itself
How a function that calls itself actually works, why every recursion needs a base case, and when recursion beats a loop.
- 09Beginner 13 min
Binary Search — Halving the Problem
Find an item in a sorted list in a handful of steps instead of thousands, and learn the boundary conditions that make it easy to get wrong.
- 10Beginner 15 min
Sorting — Putting Things in Order
How the common sorting algorithms work, why O(n log n) is the practical limit, and why you should almost always use the built-in sort.
- 11Beginner 14 min
Trees — Data That Branches
How tree structures model folders, categories and documents, plus the traversal orders you will use again and again.
- 12Intermediate 14 min
Binary Search Tree — Sorted Structure
A tree that keeps values in order so lookups take log n steps — and what happens when it degenerates into a list.
- 13Intermediate 13 min
Heap — Always Know the Smallest
A structure that keeps the smallest or largest item instantly available, and why it beats sorting for top-N and scheduling problems.
- 14Intermediate 14 min
Graph — Things and Their Connections
Model networks of relationships: friends, roads, dependencies. Learn adjacency lists, directed versus undirected, and weights.
- 15Intermediate 13 min
BFS — Exploring Level by Level
Explore a graph one ring at a time with a queue, and get shortest paths in unweighted graphs for free.
- 16Intermediate 13 min
DFS — Going Deep First
Follow one path as far as it goes before backing up. Learn DFS with recursion and with an explicit stack, plus topological sorting.
- 17Intermediate 13 min
Greedy — Take the Best Option Now
Make the locally best choice at each step and learn the crucial part: recognising when that actually produces the best overall answer.
- 18Advanced 16 min
Dynamic Programming — Remember What You Solved
Turn exponential recursion into linear code by storing subproblem answers. Learn memoisation, bottom-up tables and how to spot DP problems.
- 19Intermediate 13 min
Two Pointers — Two Positions, One Pass
Replace nested loops with two indexes moving through the data. Learn the opposite-ends and same-direction patterns and when each applies.
- 20Intermediate 14 min
Sliding Window — A Moving Range
Keep a moving range over a sequence and update its result incrementally instead of recalculating, turning O(n·k) into O(n).