Data Structures & Algorithms — Your Course

The full 90-day plan as a book: 93 pages in true day order — pattern lessons on teaching days, runnable practice pages on revision and mock days. Start at Day 1 and use Next → to walk the plan.

How to use a lesson. Read it, take the quiz, then solve its problems on LeetCode using predict → attempt → compare → encode. A problem is done when you can re-derive it — not when the tests pass. On revision and mock days, the page IS the session: open it and run the checklist.

Week 1–4 · Arrays & Hashing · Days 1–7

  1. Lesson 1 — The Seen Question Day 1
  2. Lesson 2 — Greedy: Carry the Best-So-Far Day 1
  3. Lesson 3 — Kadane: reset when the past hurts you Day 2
  4. Lesson 4 — Products without division Day 3
  5. Lesson 5 -- Two Pointers, Same Direction Day 3
  6. Lesson 6 — Two pointers, converging Day 4
  7. Lesson 7 — Boyer-Moore Majority Vote Day 4
  8. Lesson 8 — The XOR trick Day 5
  9. Lesson 9 — Prefix sums: precompute once Day 5–6
  10. Day 06 — Revision: Arrays week Day 6
  11. Day 07 — Mixed practice + mock review: Arrays Day 7

Strings & Sliding Window · Days 8–14

  1. Lesson 10 — Frequency Counting Day 8 & 12
  2. Lesson 11 — Two Pointers on Strings Day 8
  3. Lesson 12 — Sliding Window I: The Shrinking Rule Day 9
  4. Lesson 13 — Sliding Window II: Validity With a Budget Day 10
  5. Lesson 14 — Sliding Window III: Minimum Window Day 11
  6. Lesson 15 — Expand Around Center Day 13
  7. Day 13 — Revision: Strings & Sliding Window Day 13
  8. Day 14 — Mock: 3 problems, 45 minutes Day 14

Stack · Days 15–21

  1. Lesson 16 — Stack: last-in, first-out matching Day 15
  2. Lesson 17 — Monotonic Stack Intro Day 16–17
  3. Lesson 18 — Monotonic Stack: Rectangles Day 18
  4. Lesson 19 — Stack: Evaluating Expressions Day 19
  5. Day 20 — Revision: Stack week Day 20
  6. Day 21 — Mixed practice: Stack Day 21

Linked List · Days 22–30

  1. Lesson 20 — Reversing a Linked List Day 22
  2. Lesson 21 — The dummy node trick Day 23
  3. Lesson 22 — Floyd's Fast and Slow Pointers Day 24
  4. Lesson 23 — Gap Pointers: n Apart Day 25
  5. Lesson 24 — Composing Linked-List Primitives Day 26
  6. Lesson 25 — Cloning with a map Day 27
  7. Day 28 — Revision: Linked List week Day 28
  8. Day 29 — Mixed practice: Linked List Day 29
  9. Day 30 — Mock: Full Month 1 Day 30

Trees · Days 31–44

  1. Lesson 28 — Trees I: what a traversal is Day 31
  2. Lesson 29 — Trees II: Trust the Recursion Day 32
  3. Lesson 30 — Trees III: walking two trees at once Day 33
  4. Lesson 31 — Trees IV: BFS and levels Day 34 & 39
  5. Lesson 32 — Trees V: Piggyback on Height Day 35–36
  6. Day 37 — Revision: Trees basics Day 37
  7. Lesson 33 — Trees VI: Lowest Common Ancestor Day 38
  8. Lesson 34 — Trees VII: Trees as Strings Day 40
  9. Lesson 35 — Trees VIII: root-to-leaf paths Day 41
  10. Lesson 36 — Trees IX: Rebuilding from Traversals Day 42
  11. Day 43 — Revision: Advanced trees Day 43
  12. Day 44 — Mock: 3 tree problems, 60 minutes Day 44

Heap · Days 45–51

  1. Lesson 37 — Heap I: the best remaining Day 45–46
  2. Lesson 38 — Heap II: k queues, one heap Day 47
  3. Lesson 39 — Heap III: Two Heaps, One Median Day 48
  4. Lesson 40 — Heap IV: greedy scheduling with cooldown Day 49
  5. Day 50 — Revision: Heap week Day 50
  6. Day 51 — Mixed practice: Heap Day 51

Graphs · Days 52–60

  1. Lesson 41 - Graphs I: Flooding a Grid Day 52
  2. Lesson 42 — Graphs II: cloning with a map Day 53
  3. Lesson 43 - Graphs III: prerequisites and cycles Day 54
  4. Lesson 44 — Graphs IV: search backwards Day 55
  5. Lesson 45 — Graphs V: BFS on invisible graphs Day 56
  6. Lesson 46 — Graphs VI: Dijkstra, BFS with weights Day 57
  7. Day 58 — Revision: Graphs week Day 58
  8. Day 59 — Mixed practice: Graphs Day 59
  9. Day 60 — Mock: Full Month 2 Day 60

Dynamic Programming · Days 61–74

  1. Lesson 47 - DP I: the four questions Day 61
  2. Lesson 48 — DP II: take it or skip it Day 62
  3. Lesson 49 — DP III: fewest coins Day 63
  4. Lesson 50 — DP IV: longest increasing subsequence Day 64
  5. Lesson 51 — DP V: 0/1 knapsack Day 65
  6. Day 66 — Revision: DP basics Day 66
  7. Day 67 — Mixed practice: DP basics Day 67
  8. Lesson 52 - DP VI: two strings, one grid Day 68
  9. Lesson 53 — DP VII: edit distance Day 69
  10. Lesson 54 — DP VIII: Counting With Constraints Day 70
  11. Lesson 56 — DP X: interval DP Day 71
  12. Lesson 55 — DP IX: Segmentable Prefixes Day 72
  13. Day 73 — Revision: Advanced DP Day 73
  14. Day 74 — Mock: 3 DP problems, 60 minutes Day 74

System Design · Days 75–82

  1. Lesson 57 — System Design I: Scale, Latency, CAP Day 75
  2. Lesson 58 — System Design II: caching Day 76
  3. Lesson 59 — System Design III: Load Balancing Day 77
  4. Lesson 60 — System Design IV: database choices Day 78
  5. Lesson 61 — System Design V: URL shortener Day 79
  6. Lesson 62 — System Design VI: Rate Limiter Day 80
  7. Lesson 63 — System Design VII: a chat system Day 81
  8. Day 82 — Revision: redraw every design Day 82

Final Stretch · Mocks · Days 83–90

  1. Day 83 — Mock: DSA + System Design I Day 83
  2. Day 84 — Mock: DSA + System Design II Day 84
  3. Day 85 — Mock: DSA + System Design III Day 85
  4. Day 86 — Mock: DSA + System Design IV Day 86
  5. Day 87 — Mock: DSA + System Design V Day 87
  6. Day 88 — Full mock interview day Day 88
  7. Day 89 — Final revision: your weak list Day 89
  8. Day 90 — Final mock + confidence day Day 90

Appendix · How-to protocols · reference

  1. Lesson 26 — How to Run a Revision Day Appendix
  2. Lesson 27 — How to Run a Mock / Mixed Day Appendix

Reference sheets · printable · Python / Go / TypeScript / C++

Stuck or curious? Ask your teacher (the agent) — that's what it's for.