Skip to main content

Node.js / TypeScript

Weekly Goals​

  • DSA
    • Practice:
      • Trees (traversals, height, basic properties).
      • Graphs (BFS/DFS, shortest path, topological sort basics).
      • Heaps/priority queues (top-K, scheduling).
    • Perform several timed mixed sets.
  • Interview Skills
    • Emphasize clean communication and explaining trade-offs.

Use with:

Weekly Overview Table​

DayFocus
1Trees – traversals & basic properties
2Trees – lowest common ancestor & variations
3Graphs – BFS/DFS & representations
4Graphs – shortest path & topological sort (basic)
5Heaps/Priority queues – top-K & scheduling
6Mixed timed sets (trees/graphs/heaps)
7Weekly review & full mock DSA interview

Day 1 – Trees: Traversals & Basic Properties​

4-Hour Plan​

  • Block 1 (Concepts – 30–45 min)

    • Review:
      • Binary tree traversals (pre/in/post-order).
      • Level-order (BFS).

  • Block 2 (Practice – 90 min)

    • 3 tree problems:
      • Traversal, height, counting nodes/leaves.

  • Block 3 (Review – 45–60 min)

    • Write tree traversal templates.

  • Block 4 (Light Backend – 30 min)

    • Brief glance over system design notes.

6-Hour Plan​

  • Add:
    • Extra tree problem (30–45 min):
      • Slightly more complex (e.g., path sum).

Day 2 – Trees: LCA & Variations​

4-Hour Plan​

  • Block 1 (Concepts – 30–45 min)

    • Lowest common ancestor (LCA).
    • BST vs general tree basics.

  • Block 2 (Practice – 90 min)

    • 3 problems:
      • 1 LCA problem.
      • 2 other tree variations (e.g., symmetric tree, diameter).

  • Block 3 (Review – 45–60 min)

    • Document LCA approaches (for BST vs general tree).

  • Block 4 (Light Backend – 30 min)

    • Another quick skim of earlier backend notes.

6-Hour Plan​

  • Add:
    • Extra tree problem (30–45 min) if comfortable.

Day 3 – Graphs: BFS/DFS & Representations​

4-Hour Plan​

  • Block 1 (Concepts – 30–45 min)

    • Graph representations:
      • Adjacency list vs adjacency matrix.
    • BFS vs DFS and typical use cases.

  • Block 2 (Practice – 90 min)

    • 3 graph problems:
      • Connectivity, number of components, simple path existence.

  • Block 3 (Review – 45–60 min)

    • Write BFS/DFS template code.

  • Block 4 (Light Backend – 30 min)

    • Relate to:
      • How graphs appear in backend (e.g., dependency graphs).

6-Hour Plan​

  • Add:
    • Extra graph problem (30–45 min).

Day 4 – Graphs: Shortest Path & Topological Sort (Basics)​

4-Hour Plan​

  • Block 1 (Concepts – 30–45 min)

    • Dijkstra’s algorithm basics (priority queue).
    • Topological sort for DAGs.

  • Block 2 (Practice – 90 min)

    • 2–3 problems:
      • 1 shortest path (unweighted BFS or weighted simple).
      • 1 topological sort problem.

  • Block 3 (Review – 45–60 min)

    • Summarize when to use BFS vs Dijkstra.

  • Block 4 (Light Backend – 30 min)

    • Tie back to system design examples (e.g., scheduling, dependency resolution).

6-Hour Plan​

  • Add:
    • Extra shortest path problem (30–45 min) if confident.

Day 5 – Heaps/Priority Queues: Top-K & Scheduling​

4-Hour Plan​

  • Block 1 (Concepts – 30–45 min)

    • Min-heap vs max-heap.
    • Priority queues for scheduling.

  • Block 2 (Practice – 90 min)

    • 3 problems:
      • Top-K elements.
      • Merge K sorted arrays/lists.
      • Basic scheduling or frequency-based problems.

  • Block 3 (Review – 45–60 min)

    • Record heap-based patterns and common pitfalls.

  • Block 4 (Light Backend – 30 min)

    • Relate heaps to backend tasks (e.g., job scheduling).

6-Hour Plan​

  • Add:
    • Extra heap problem (30–45 min).

Day 6 – Mixed Timed Sets (Trees/Graphs/Heaps)​

4-Hour Plan​

  • Block 1 (Timed Set 1 – 90 min)

    • 2 problems:
      • 1 tree problem.
      • 1 graph or heap problem.
    • Time-box ~40–45 min each.

  • Block 2 (Timed Set 2 – 60 min)

    • 1 additional problem of your choice.

  • Block 3 (Review – 30–45 min)

    • Summarize performance and gaps.

6-Hour Plan​

  • Add:
    • Extra quick problem (30–45 min) for the weakest area.

Day 7 – Weekly Review & Full Mock DSA Interview​

4-Hour Plan​

  • Block 1 (Mock Interview – 90 min)

    • Simulate:
      • 2 DSA problems (mix arrays/trees/graphs).
    • Practice speaking your thought process.

  • Block 2 (Review – 60 min)

    • Analyze:
      • Time management.
      • Communication.
      • Correctness.

  • Block 3 (Planning – 30–45 min)

6-Hour Plan​

  • Add:
    • Third problem (30–45 min) if you have energy, focusing on your weakest topic.