DSA Master Plan — JavaScript

1 hour/day · 6 days/week · ~21 weeks to NeetCode 150 completion · no sugarcoating

non-negotiable rules
1.No tutorials. If you're blank after 20 min, look at only the approach — close it, then code from memory.
2.Always analyze your own solution's time + space complexity before checking answers. Every single time.
3.If you miss a day, you do not "catch up" with double problems the next day. Resume exactly where you stopped.
4.No AI help during attempt. Claude is for post-mortem only — after you've submitted or run out of time.
5.Every solution you write goes in a local JS file with your own comments on the approach. Not in browser — in a file.
6.Sunday is review day, not a rest day. Pick 2 problems from any previous week. No new topics on Sundays.
your 1 hour — how to split it
0 – 10 min
recall
Without opening anything, write down what you remember from yesterday. Approach, code pattern, complexity. Forces retrieval.
10 – 50 min
problem
40 min hard limit. Read problem, think 5 min before coding. Submit when done or time's up. No extensions.
50 – 57 min
debrief
Check optimal solution. What did you miss? Write one line on the pattern. Compare complexities.
57 – 60 min
log
Add to your local JS file. Problem name, your approach, optimal approach, complexity. 3 lines max.
phase 0 — dp audit · week 1
audit is your dp actually solid? week 1 of 21
week 1 DP audit — 6 problems, honest diagnosis do not skip this ▼

Attempt each cold. No reviewing DP first. The results tell you where you actually stand.

Mon0/1 KnapsackGFG: 0/1 Knapsackmedium — if this takes >50 min, your DP base is weak
TueCoin ChangeLC #322 Coin Changemedium
WedLCSLC #1143 Longest Common Subsequencemedium
ThuEdit DistanceLC #72 Edit Distancehard
FriLISLC #300 Longest Increasing Subsequencemedium
SatPartition SumLC #416 Partition Equal Subset Summedium
SunreviewRe-solve whichever of the above took you longest. Write the pattern in plain English in your file.
If Mon–Fri averaged under 45 min each with correct solutions → DP is solid, continue. If 2+ problems took the full hour or you couldn't finish → insert the DP Deep Dive at the end before NeetCode 150. Don't lie to yourself.
phase 1 — foundations + core patterns · weeks 2–10
critical data structures + patterns that block medium problems weeks 2–10
week 2 Stack LIFO fundamentals · most asked easy/medium ▶
LIFOparentheses matchingexpression evaluationnested structure
Stack = last in, first out. If a problem says "matching", "nesting", "closest previous", or "undo" — think stack. This week is short but every problem here is an interview classic.
Monconcept + easyLC #20 Valid Parentheseseasy — 20 min concept: stack operations in JS (push, pop, peek). Then code.
TuemediumLC #155 Min Stackmedium — design problem, O(1) getMin
WedmediumLC #150 Evaluate Reverse Polish Notationmedium
ThumediumLC #394 Decode Stringmedium — nested stack usage
FrimediumLC #735 Asteroid Collisionmedium — simulation with stack
Sathard attemptLC #224 Basic Calculatorhard — stack + recursion. Full hour.
SunreviewRe-do Valid Parentheses and Decode String from memory. Write the stack template in your own words.
week 3 Linked List pointer manipulation · reversal · merge ▶
singly linkedpointer rewiringdummy node trickreverse in-place
Every linked list problem is about pointer manipulation. Draw boxes and arrows on paper before coding. The dummy node trick (creating a fake head) simplifies 90% of edge cases.
Monconcept + 2 easyLC #206 Reverse Linked Listeasy + LC #21 Merge Two Sorted Listseasy — 20 min concept, then code both
TuemediumLC #143 Reorder Listmedium — uses reverse + merge + find middle
WedmediumLC #19 Remove Nth Node From Endmedium — two pointer gap technique
ThumediumLC #138 Copy List with Random Pointermedium — hash map + linked list
FrimediumLC #2 Add Two Numbersmedium — carry logic + list building
Sathard attemptLC #23 Merge K Sorted Listshard — divide and conquer or heap approach
SunreviewRe-do Reverse Linked List and Reorder List from memory. These two patterns cover 80% of linked list problems.
week 4 Two Pointers pattern · fastest week ▶
left/right pointerfast/slow pointershrink window
Day 1 concept read: 20 min max. Two pointer = two indices moving toward each other (or same direction). That's the entire idea. Now code.
Monconcept + easyLC #125 Valid Palindromeeasy — 20 min concept, 40 min code
TuemediumLC #167 Two Sum IImedium
WedmediumLC #11 Container With Most Watermedium
ThumediumLC #15 3Summedium — sort first, then two pointer
Frifast/slowLC #141 Linked List Cycleeasy + LC #287 Find Duplicatemedium
Sathard attemptLC #42 Trapping Rain Waterhard — attempt it, you may not finish, that's fine
SunreviewRe-solve 3Sum and Trapping Rain Water from memory only.
week 5 Sliding Window fixed + variable both ▶
fixed windowvariable windowexpand/shrink
Monconcept + easyLC #643 Max Average Subarray Ieasy — fixed window, 20 min concept
TuemediumLC #3 Longest Substring Without Repeatingmedium
WedmediumLC #424 Longest Repeating Char Replacementmedium
ThumediumLC #567 Permutation in Stringmedium
FrimediumLC #904 Fruit Into Basketsmedium
Sathard attemptLC #76 Minimum Window Substringhard
SunreviewRe-solve LC #3 and LC #424 from scratch. These two patterns cover 80% of sliding window problems.
week 6 Hashing (deep) frequency maps, prefix sum combos ▶
Map/Set in JSfrequency counthash collisionscustom hash
Monconcept + easyLC #242 Valid Anagrameasy — concept: Map vs obj, O(1) lookup, collision theory (20 min)
TuemediumLC #49 Group Anagramsmedium
WedmediumLC #347 Top K Frequent Elementsmedium — bucket sort approach
ThumediumLC #271 Encode and Decode Stringsmedium
FrimediumLC #128 Longest Consecutive Sequencemedium — O(n) using Set
SatcomboLC #560 Subarray Sum Equals Kmedium — hashing + prefix sum
SunreviewRe-do LC #128 and LC #560. These use hashing non-obviously — critical pattern.
week 7 Trees — Binary Tree Fundamentals DFS + BFS · #1 most asked category ▶
DFS (preorder/inorder/postorder)BFS (level order)recursion on treesheight/depth
Trees are the single most asked topic in interviews. Every tree problem is either DFS (go deep first) or BFS (go level by level). Master the recursive DFS template: base case → process left → process right. That's 70% of tree problems.
Monconcept + 2 easyLC #226 Invert Binary Treeeasy + LC #104 Maximum Deptheasy — 20 min concept: DFS vs BFS, recursive tree traversal
Tue2 easyLC #543 Diameter of Binary Treeeasy + LC #110 Balanced Binary Treeeasy
Wed2 easyLC #100 Same Treeeasy + LC #572 Subtree of Another Treeeasy
Thumedium (BFS)LC #102 Binary Tree Level Order Traversalmedium — queue-based BFS template
FrimediumLC #199 Binary Tree Right Side Viewmedium — BFS variation
SatmediumLC #1448 Count Good Nodes in Binary Treemedium — DFS with state passing
SunreviewRe-do Invert Binary Tree, Level Order Traversal, and Right Side View from memory. Write both DFS and BFS templates in your file.
week 8 Trees — BST + Advanced BST properties · construction · hard tree problems ▶
BST invariant (left < root < right)inorder = sortedLCAtree construction
BST key insight: an inorder traversal of a BST gives you a sorted array. Use this property in every BST problem. For construction problems, preorder tells you the root — then split.
MonmediumLC #98 Validate Binary Search Treemedium — pass min/max bounds down
TuemediumLC #230 Kth Smallest Element in BSTmedium — inorder traversal
WedmediumLC #235 Lowest Common Ancestor of BSTmedium
ThumediumLC #105 Construct Tree from Preorder + Inordermedium
Frihard attemptLC #124 Binary Tree Maximum Path Sumhard — global max + DFS return value
Sathard attemptLC #297 Serialize and Deserialize Binary Treehard
SunreviewRe-do Validate BST and Construct Tree from Preorder + Inorder from memory. These two test if you truly understand tree structure.
weeks 9–10 Backtracking hardest concept in phase 1 · 2 weeks ▶
choose/explore/unchooserecursion treepruningstate restoration
Before each problem, draw the recursion tree on paper. Not optional. Backtracking problems become obvious once you see the tree. Skip this and you'll keep guessing.
W9 MonconceptStudy the template: choose → recurse → unchoose. 20 min concept, then implement subsets by hand in JS.
W9 TuemediumLC #78 Subsetsmedium
W9 WedmediumLC #46 Permutationsmedium
W9 ThumediumLC #39 Combination Summedium
W9 FrimediumLC #40 Combination Sum IImedium — pruning duplicates
W9 SatmediumLC #90 Subsets IImedium
W9 SunreviewRe-do Permutations and Combination Sum from memory.
W10 MonmediumLC #79 Word Searchmedium
W10 TuemediumLC #131 Palindrome Partitioningmedium
W10 WedmediumLC #17 Letter Combinationsmedium
W10 Thuhard attemptLC #51 N-Queenshard — benchmark problem. Full hour. No shortcuts.
W10 Frihard attemptLC #37 Sudoku Solverhard
W10 SatmediumLC #22 Generate Parenthesesmedium — deceptively instructive
W10 SunreviewRe-do Word Search and N-Queens. If N-Queens still breaks you, spend extra time. Don’t skip it.
phase 2 — advanced patterns · weeks 11–20
advanced graph algorithms + advanced data structures + remaining patterns weeks 11–20
week 11 Heaps / Priority Queue implement MinHeap in JS first — no skipping ▶
MinHeapMaxHeapheapify up/downtop-K pattern
Day 1 is mandatory implementation day. JS has no built-in heap. Write a MinHeap class with insert(), extractMin(), heapifyUp(), heapifyDown(). Do not skip this — you'll need it in timed problems.
Monbuild itImplement MinHeap + MaxHeap in JS from scratch. No LeetCode today. Full hour on the structure.
TuemediumLC #215 Kth Largest Elementmedium — use your MinHeap
WedmediumLC #973 K Closest Points to Originmedium
ThumediumLC #621 Task Schedulermedium
FrimediumLC #355 Design Twittermedium — heap + OOP
Sathard attemptLC #295 Find Median from Data Streamhard — two heaps pattern
SunreviewRe-write MinHeap from memory. Then re-do LC #295. Two-heap pattern is critical.
week 12 Binary Search (on answer space) you know basic BS — this is the next level ▶
search on value not indexfeasibility functionlo/hi convergence
Monconcept + warmupLC #33 Search in Rotated Arraymedium — 20 min: read "binary search on answer space", then code
TuemediumLC #153 Find Min in Rotated Arraymedium
WedmediumLC #875 Koko Eating Bananasmedium — answer space BS begins here
ThumediumLC #1011 Capacity to Ship Packagesmedium
FrimediumLC #981 Time Based Key-Value Storemedium
Sathard attemptLC #4 Median of Two Sorted Arrayshard — hardest binary search. Full attempt.
SunreviewRe-do Koko and Capacity to Ship. Nail the feasibility function template cold.
week 13 Graphs — BFS/DFS Fundamentals grids + adjacency lists · must know before advanced graphs ▶
adjacency listBFS (queue)DFS (stack/recursion)visited setgrid traversal
Graph = nodes + edges. Represent with adjacency list (Map of arrays). BFS uses a queue, DFS uses recursion or a stack. Grid problems are just graphs where each cell connects to its 4 neighbors. Learn to convert between grids and graphs mentally.
Monconcept + mediumLC #200 Number of Islandsmedium — 20 min concept: adjacency list, BFS/DFS templates. Then code.
TuemediumLC #133 Clone Graphmedium — DFS + hash map for visited
WedmediumLC #695 Max Area of Islandmedium
ThumediumLC #417 Pacific Atlantic Water Flowmedium — reverse BFS from edges
FrimediumLC #994 Rotting Orangesmedium — multi-source BFS
SatmediumLC #130 Surrounded Regionsmedium — boundary DFS
SunreviewRe-do Number of Islands and Pacific Atlantic from memory. Write your BFS and DFS graph templates.
week 14 Topological Sort + Dijkstra builds directly on your graph knowledge ▶
DAG orderingKahn's algorithmweighted shortest pathmin-heap + adjacency
Monconcept + topoLC #207 Course Schedulemedium — 20 min topo sort concept (Kahn's BFS-based)
Tuetopo mediumLC #210 Course Schedule IImedium — return the actual order
Wedtopo mediumLC #802 Find Eventual Safe Statesmedium
ThuDijkstra conceptLC #743 Network Delay Timemedium — 20 min Dijkstra theory, then code using your MinHeap
FriDijkstra mediumLC #1631 Path With Minimum Effortmedium
SatDijkstra mediumLC #787 Cheapest Flights Within K Stopsmedium
SunreviewRe-do Course Schedule II and Network Delay Time. These are the template problems for each algorithm.
week 15 Union-Find (DSU) implement with path compression + union by rank ▶
find with path compressionunion by rankcycle detection
Day 1: implement DSU class from scratch with path compression and union by rank. ~30 lines. Get it right once, use it forever.
Monbuild + mediumImplement DSU (30 min), then LC #547 Number of Provincesmedium
TuemediumLC #684 Redundant Connectionmedium — cycle detection
WedmediumLC #261 Graph Valid Treemedium
ThumediumLC #323 Connected Componentsmedium
FrimediumLC #721 Accounts Mergemedium — DSU + hashing combined
Sathard attemptLC #778 Swim in Rising Waterhard
SunreviewRe-write DSU from memory. Then re-do Accounts Merge.
week 16 Monotonic Stack pattern recognition week ▶
next greater elementmaintain order invariantspan/histogram
Monconcept + easyLC #496 Next Greater Element Ieasy — 20 min concept: monotonic stack = stack maintaining an order invariant
TuemediumLC #739 Daily Temperaturesmedium
WedmediumLC #853 Car Fleetmedium
ThumediumLC #901 Online Stock Spanmedium
Frihard attemptLC #84 Largest Rectangle in Histogramhard — benchmark. Full hour.
Sathard attemptLC #85 Maximal Rectanglehard — builds on LC #84
SunreviewRe-do Daily Temperatures and Largest Rectangle in Histogram from memory.
week 17 Trie build it first — every problem uses it ▶
prefix treeTrieNode classinsert/search/startsWith
Monbuild itLC #208 Implement Triemedium — full hour implementing. Foundation for everything this week.
TuemediumLC #211 Design Add and Search Wordsmedium
WedmediumLC #1268 Search Suggestions Systemmedium
Thuhard attemptLC #212 Word Search IIhard — Trie + backtracking combined
FrimediumLC #648 Replace Wordsmedium
SatmediumLC #720 Longest Word in Dictionarymedium
SunreviewRe-write Trie class from scratch. Attempt Word Search II again if Thursday was incomplete.
week 18 Greedy locally optimal → globally optimal · distinct from DP ▶
Kadane's algorithmgreedy choice propertysorting + greedyinterval scheduling
Greedy ≠ DP. Greedy works when the locally optimal choice at each step leads to the global optimum. The trick is proving it works — or recognizing the pattern from known problems. If greedy fails, it's usually DP instead.
Monconcept + mediumLC #53 Maximum Subarraymedium — Kadane's algorithm. 20 min concept: greedy vs DP distinction.
TuemediumLC #55 Jump Gamemedium
WedmediumLC #45 Jump Game IImedium
ThumediumLC #134 Gas Stationmedium — circular greedy
FrimediumLC #763 Partition Labelsmedium
Sat2 mediumLC #846 Hand of Straightsmedium + LC #678 Valid Parenthesis Stringmedium
SunreviewRe-do Jump Game II and Gas Station from memory. Write why greedy works for each.
week 19 Intervals sort by start · merge/insert/overlap — very common ▶
sort by start timemerge overlappingsweep linemin heap for end times
Almost every interval problem starts with: sort by start time. Then decide: merge, insert, or count overlaps. The pattern is small but shows up in every interview round.
Monconcept + mediumLC #56 Merge Intervalsmedium — 20 min concept: interval representation, sort strategy. Then code.
TuemediumLC #57 Insert Intervalmedium
WedmediumLC #435 Non-overlapping Intervalsmedium — greedy + intervals combined
ThueasyLC #252 Meeting Roomseasy — sort + check overlap (premium — use LintCode #920 if needed)
FrimediumLC #253 Meeting Rooms IImedium — min heap approach (premium — use LintCode #919 if needed)
Sathard attemptLC #1851 Minimum Interval to Include Each Queryhard
SunreviewRe-do Merge Intervals and Non-overlapping Intervals from memory. Write the interval template.
week 20 Bit Manipulation shortest learning curve, solid payoff ▶
XOR tricksbit maskingn & (n-1)left/right shift
Day 1: spend 20 min writing all core bit ops in JS — AND, OR, XOR, NOT, left shift, right shift, n&(n-1), n&1. Run them in Node, see the output. Then code.
Monconcept + 2 easyLC #136 Single Numbereasy + LC #191 Number of 1 Bitseasy
Tue2 easyLC #338 Counting Bitseasy + LC #190 Reverse Bitseasy
Wedeasy + mediumLC #268 Missing Numbereasy + LC #371 Sum of Two Integersmedium
ThumediumLC #137 Single Number IImedium
FrimediumLC #78 Subsetsmedium — re-solve using bitmask (you did backtracking in W9)
SatmediumLC #421 Maximum XOR of Two Numbersmedium — Trie + bit
SunreviewWrite every bit trick from memory. Re-do Sum of Two Integers without looking anything up.
phase 3 — execution · week 21 onwards
execution NeetCode 150 — in order, no skipping week 21+
Go to neetcode.io/practice and work through all 150 problems in their listed order. By this point you have every building block — all 18 NeetCode categories are covered. Do 1 problem per session (your daily hour). Some days you'll finish in 30 min if you've seen the pattern — that's fine, spend remaining time re-reading your solution log. Completion of all 150 = genuinely interview-ready at a solid mid-level. After that, do LeetCode weekly contests to stay sharp.
optional — dp deep dive (insert before neetcode only if phase 0 showed weakness)
weeks 21–22 DP deep dive — insert before NeetCode if needed 2D DP · knapsack variants · interval DP ▶
1D DP2D DP0/1 knapsackunbounded knapsackinterval DP
W21 Mon1D DPLC #70 Climbing Stairseasy + LC #198 House Robbermedium
W21 Tue1D DPLC #213 House Robber IImedium + LC #91 Decode Waysmedium
W21 WedknapsackLC #518 Coin Change IImedium — unbounded knapsack
W21 Thu2D DPLC #62 Unique Pathsmedium + LC #63 Unique Paths IImedium
W21 Fri2D DPLC #494 Target Summedium
W21 Satstring DPLC #97 Interleaving Stringhard
W21 SunreviewRe-do House Robber II and Coin Change II from memory.
W22 MonhardLC #312 Burst Balloonshard — interval DP
W22 TuehardLC #10 Regular Expression Matchinghard
W22 Wed–SunNeetCode DPStart NeetCode 150 DP section. Continue until complete, then proceed with full NeetCode 150 from the top.