The Complete DSA Study Plan
A free six-month study plan to master data structures and algorithms, built around three resources, structured learning, and spaced repetition.
If you want to work at companies like Google, Meta, or Netflix, data structures and algorithms are basically a requirement. And if you've ever tried to learn this stuff and given up, or you've been putting it off because honestly, it looks too hard, you're in the right place.
This is the exact three-step plan I'd give anyone who wants to finally master DSA and walk into an interview feeling confident. It also covers the one mindset shift that stops most people from quitting after two weeks.
The mindset shift that stops you quitting
DSA isn't hard because you need to be incredibly smart. It's hard because almost everyone learns it in the wrong order. They jump straight into LeetCode, get destroyed by easy problems, and assume they're not cut out for this. They are, they've just been pointed in the wrong direction.
LeetCode labels problems as easy, medium, and hard. But what they're really measuring is:
How hard is this problem given you already know the relevant pattern?
That's very different from "how hard is this if you've never seen the pattern before." Literally nobody on this planet could solve a binary tree problem if they've never implemented a binary tree.
So don't feel bad if you can't solve a question off the bat. Go back, understand the pattern, then try again. Do it this way and it actually starts to feel like you're learning something, you'll get 90% of problems solved with no hints at all.
Why random LeetCode doesn't work
You may have heard that you should read a thick algorithms textbook, or just grind random LeetCode problems. Both of these will make you quit.
Take a typical "easy" question:
Given a string, find the longest possible substring with no repeating characters. Solve it in O(n) time.
If you already know sliding window and hashmaps, this is straightforward. If you don't, this "easy" problem is basically impossible, and you'll walk away feeling stupid.
Learning DSA isn't about solving novel algorithms on the fly. It's about recognising the patterns that apply to a problem and implementing them. Once you can do that, it becomes ten times easier.
The plan below is built around that idea: focus on one problem type at a time until the pattern is in your head, then move on.
Resource 1 — LeetCode Interview Crash Course
Start here. The Interview Crash Course takes you through one technique at a time, with clear explanations, walkthroughs, and curated practice, so you understand a topic completely before moving on.
It covers the core categories:
- Arrays and strings
- Hashmaps and sets
- Linked lists
- Stacks and queues
- Trees and graphs
- Heaps
- Greedy algorithms
- Binary search
- Backtracking
- Dynamic programming
Each chapter includes:
- An explanation of the data structure or algorithm, what it's good at, how it's implemented, time and space complexity.
- The common patterns and tricks that come up.
- Several worked examples with visual aids and complexity analysis.
- Curated practice problems to build muscle memory.
- A short quiz at the end.
- A list of optional bonus problems to reinforce the chapter.
There's also a tools chapter with code templates for every common pattern, cheatsheets for time and space complexity, and a flowchart for picking the right data structure for a problem.
No LeetCode Premium needed
All premium content tied to the crash course is unlocked for you when you take the course, even if you're not a Premium member.
Pro tips
- If you're stuck on a problem, paste it into Claude and ask for a hint, not the answer. It can bring the explanation down to where you're at and fill in the gap. - As you go through each chapter, write down the template for that pattern. Next time you see a similar problem you can reference it, and after referencing it enough times it just becomes baked into your brain.
Resource 2 — Grokking Algorithms
The second resource is the book Grokking Algorithms by Aditya Bhargava.
It takes a similar grouped approach to the crash course but pairs every concept with beautiful illustrations and analogies for why a particular algorithm is useful.
If the crash course gives you the reps, Grokking gives you the intuition. The two together stick way better than either one on its own.
Order doesn't really matter, start with whichever learning style you prefer. If you just want to start writing code, do the crash course first. If you prefer to build intuition before touching a keyboard, read the book first.
Resource 3 — NeetCode 150
Once you've been through the crash course and Grokking, the only thing left to do is put in the reps.
NeetCode 150 is 150 of the most common questions that come up in software engineering interviews. They're grouped by category, arrays and hashing, two pointers, sliding window, and so on, so you can keep focusing on one pattern at a time.
This is where you apply spaced repetition. As each category starts to feel familiar, leave more time between attempts so the pattern becomes permanent.
For example, with linked lists:
- Day 1–3: do several linked-list problems in a row to get the concept in your head.
- Wait two days, then do another linked-list problem.
- Wait a week, then do another.
- Wait two weeks, then do another.
By the third or fourth pass, the pattern is baked in.
The six-month schedule
A realistic pace that works for most people:
| Months | Focus |
|---|---|
| 0–1 | Mindset + start the LeetCode Crash Course. Begin reading Grokking Algorithms in parallel. |
| 1–3 | Work through the crash course, one category per week. Write down the template for each pattern. |
| 3–4 | Finish the crash course's tools chapter. Re-read the Grokking chapters that didn't fully click. |
| 4–6 | NeetCode 150, category by category, using spaced repetition to lock the patterns in. |
If you stick to one category a week through the crash course and Grokking, you can get through them in roughly 3 months. After that, it's just NeetCode reps for a couple more months.
You can move faster or slower, the categories and the spaced repetition are what matter, not the calendar.
Practice tips
A few things that made a huge difference for me:
- Work problems out on paper or in a spreadsheet first. Some problems look impossible when you're staring at code. Write down each step manually and they often become obvious. Linked-list problems especially.
- Keep a personal "templates" file. One template per pattern, sliding window, two pointers, BFS, DFS, binary search, backtracking, DP. Reference it as you practise. After enough references you won't need to.
- Use Claude for hints, not answers. Ask "what category does this fall into?" or "what's the first step here?" not "what's the solution?". You want the click, not the copy-paste.
- Don't feel bad about looking at a solution. If you've spent 30 minutes and you're still stuck, read the solution, understand it, then re-implement it from scratch the next day.
TL;DR
Three resources, in this order:
- LeetCode Interview Crash Course — pattern-by-pattern, no Premium needed.
- Grokking Algorithms by Aditya Bhargava — for the intuition.
- NeetCode 150 — for the reps, using spaced repetition.
Plus the mindset shift: you're not solving novel problems, you're recognising patterns you've already practised. Stick to one category at a time, write down the templates, and you'll get through the crash course and the book in 3–6 months. After that, you're just putting in the reps.