New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom Big O notation to a pattern-matching toolkit built for the coding interview.
A 15-step learning path. Follow it in order, or jump to what you need.
For developers prepping for coding interviews, or anyone who wants real command of data structures and algorithms instead of just enough recall to pass a quiz. Plan on about 7 to 10 weeks at a few hours a week, moving from complexity analysis through core structures, recursion, trees and graphs, and into the pattern library interviewers actually test against. This path stays inside data structures, algorithms, and interview problem-solving; it does not cover the distributed-systems and scalability trade-offs of the System Design path, or the broader nine-subject computer-science canon (operating systems, networking, compilers, and more) covered by Computer Science Fundamentals. By the end you can analyze any algorithm's time and space complexity, implement and traverse trees and graphs from scratch, and recognize which of a dozen interview patterns a new problem is actually testing.
Expected: comfortable writing and reading basic code in any programming language (loops, functions, arrays). Helpful but not required: prior exposure to a first algorithms or data structures course.
Open this first and within the hour you can look at any loop or recursive call and predict whether it crawls or flies as input grows, the yardstick every step below gets measured against.
Walk the whole toolbox once with the complexity lens from step 1 in hand, arrays through disjoint sets, so the deep dives into hash tables, trees, and graphs later on start from a shared map instead of a blank page.
Put that complexity lens to work on the algorithms every interview loop opens with: compare quicksort against merge sort on the exact trade-offs step 1 just taught you to spot.
You can price an algorithm's growth before ever running it and name every core data structure and sort by its trade-offs. Next up: the structure that shows up in more solutions than any other, and the recursive mindset behind it.
Finish this section to unlock.
+100 XP
Go deep on the single structure from step 2's survey that shows up in more LeetCode solutions than any other: O(1) average lookups, collision handling, and the trick of trading space for speed.
This is where the function-calls-itself idea finally clicks, or keeps refusing to; expect to come back to it, because divide and conquer, trees, and dynamic programming below all lean on this exact skill.
Turn the recursion from step 5 into a design strategy: split a problem, solve the pieces, combine them, the same pattern behind merge sort from step 3 and the recurrence math that predicts its complexity.
Apply the recursive thinking from step 5 to the hierarchical structures step 2 only sketched: BST balancing, segment trees, tries, and the traversal templates interviews ask for by name.
You can write a hash-table solution from memory and trust recursive code enough to design with it, trees included (a few minutes of due flashcards keeps chapter 1's complexity math sharp while you're here). Next up: turning single structures into full networks.
Finish this section to unlock.
+100 XP
Generalize the trees from step 7 into networks with cycles and multiple parents: BFS and DFS traversal, representations, and the shortest-path groundwork step 11 builds on.
Pick up the structure that answers 'are these two nodes connected' in near constant time, the piece Kruskal's algorithm in step 11 depends on and the graphs from step 8 only gestured at.
Return to the heap overview from step 2 and go deep: linear-time build-heap, the top-k pattern, and the priority queue that Dijkstra's algorithm in step 11 runs on.
Push the graphs from step 8 further with the exact algorithms interviewers expect coded from memory: Dijkstra's powered by the heap from step 10, Kruskal's powered by the union-find from step 9.
This is the second concept that trips almost everyone up at first: turning the recursion from step 5 into a table so overlapping subproblems stop recomputing, expect to revisit knapsack and grid problems more than once.
You can traverse a graph, run Dijkstra's and Kruskal's from memory, and turn a brute-force recursive solution into a dynamic-programming table that actually finishes. Next up: a couple of specialist toolkits, then the pattern library that ties it all together.
Finish this section to unlock.
+100 XP
Take this if you're aiming at companies known for bit-trick questions: XOR swaps, bitmasks, and the O(1) tricks that turn a brute-force loop from step 3 into a single instruction.
Reach for this if the interviews you're prepping for lean text-heavy: KMP, Rabin-Karp, and the suffix structures that go past basic string methods into pattern-matching problems brute force can't finish in time.
Pull every step above into one interview-ready toolkit: two pointers, sliding window, the BFS and DFS templates from step 8, the backtracking from step 5, and the DP recognition skill from step 12, matched to the signal that tells you which one to reach for.
You can size up any problem's complexity, reach for the right structure or pattern on sight, and code trees, graphs, and dynamic programming solutions from memory, that's the Data Structures & Algorithms Practitioner badge, earned.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.