Video summary

Master DSA in 90 Days | Beginners Roadmap | GeeksforGeeks

Main summary

Key takeaways

Educational

Main Ideas and Lessons Conveyed

1) Video purpose: a “DSA in 90 days” roadmap

  • The mentor shares a beginner-friendly plan to learn Data Structures and Algorithms (DSA) in roughly 3 months (90 days).
  • The roadmap is structured as a time-split sequence of topics, moving from easy → medium → (later) hard problem practice.

2) GeeksforGeeks “390 Challenge” (90-day motivation/discount)

  • The video references GeeksforGeeks’ “90 days challenge”:
    • If a learner purchases a course and completes 90% of that course within 90 days, they receive 90% refund/discount on the paid amount (described as “90% off the refund”).
  • Advice:
    • Research courses before buying (reviews, course description, and details).
    • Use the challenge as motivation to actually finish.

3) What DSA is (core definitions)

  • DSA = Data Structures + Algorithms
  • Data structures are ways to organize data for efficient access and modification.
    • Examples: arrays, linked lists, queues, trees, graphs
  • Algorithms are step-by-step procedures to solve problems efficiently.
    • Examples:
      • Sorting: quick sort, merge sort
      • Searching: binary search, linear search
  • Key emphasis:
    • There are many ways to solve a problem, but the goal is to learn the most efficient approach.
    • Strong learners may later design even better algorithms.

4) Language choice philosophy (C++ as reference, alternatives OK)

  • The mentor uses C++ as the reference because it was the first language he learned.
  • He argues DSA can be learned in C++, Java, Python, or C—choose what you’re comfortable with.
  • Common concerns addressed:
    • Python is acceptable for DSA, and companies do accept it (he mentions contacts using Python + DSA).
    • He discourages learning DSA in JavaScript specifically for large-company placements, claiming it lacks some core DSA support/structures.

5) Before DSA: learn basic programming foundations

  • Recommendation: understand a programming language fully first.
  • “Must know” C++ basics (as listed):
    • Syntax
    • Variables and constants
    • Data types and memory sizes (e.g., integers, floats, characters)
    • Control flow: if-else, for, while, do-while, switch
    • Functions (including function types)
    • OOP knowledge recommended (at least understand concepts), since some DSA questions may require it (though not in most cases).

6) High-level time plan structure

  • Overall theme:
    1. Build foundations first
    2. Cover major data structures/topics
    3. Progress problem-solving: mostly easy → medium
    4. Delay “hard” until medium is comfortable
    5. Becoming strong in hard problems may take more than 90 days

7) Problem-solving strategy (how to practice effectively)

  • For each topic, practice mainly:
    • Easy problems first
    • Then medium problems
  • For arrays (sorting/searching):
    • Don’t try to memorize every algorithm deeply at first.
    • Learn at least one sorting algorithm you find fastest/most comfortable (examples mentioned: merge/quick/bubble).
    • Revise later.
  • Placement/interview outcomes:
    • It’s not about solving “thousands” randomly—solve the right problems.
    • Use curated “sheets” shared by successful interviewers/YouTubers, with linked questions from GFG/LeetCode.

8) Learning method / notes

  • Prefer writing code and saving program-based notes (with comments) rather than extensive handwritten notes.
  • Revise periodically (e.g., around monthly).

Detailed Instruction-Style Roadmap (Topic-by-Topic with Suggested Days)

“Roadmap in 90 days” with specific time allocations (as stated)

Prerequisites (before starting the 90-day DSA plan)

  • Learn programming language basics first
    • Recommended: 2–3 weeks (or up to ~1 month for total beginners)
  • Have OOP knowledge (at least concepts), especially for questions that may require it.

90-Day DSA Roadmap (from Foundations to Mediums)

Days 1–2: Space and Time Complexity

  • Learn:
    • Definitions and basic understanding
  • Practice:
    • Calculating time complexity for:
      • single loops
      • nested loops
      • multiple loops
    • Simple space complexity checks
  • Use cases:
    • Compare which program runs faster using time complexity
  • Suggested emphasis:
    • Time complexity > space complexity (claim: modern memory reduces the impact of space)

Days 3–? (first major block): Arrays

  • Suggested time: ~10 days total (including 1D and 2D concepts)
  • Learn:
    • Arrays as contiguous memory with index access
    • 1D arrays and 2D arrays
  • Practice problems:
    • Reverse array
    • Searching elements
    • Sorting-related problems
  • Sorting guidance:
    • Don’t memorize every sorting algorithm initially.
    • Learn programs/logic for several, but master at least one sorting algorithm that feels fastest/most comfortable.
    • Do easy + medium later.
    • Prefer competitive/story-based questions (not only direct queries).
  • Practice guidance:
    • Aim for comfortable easy array questions (reverse, search, sort).
    • Use GeeksforGeeks and LeetCode.
    • Prefer competitive-style problems.

Next 5 days: Linked List

  • Learn:
    • Linked list as a linear structure of nodes connected via pointers
  • Why it matters:
    • Claimed usefulness in cases where it saves memory and fits specific scenarios
  • Example use case (illustration):
    • browser back/forward navigation

Next 3 days: Stack

  • Learn:
    • LIFO (Last In First Out)
  • Practice:
    • easy questions

Next 3 days: Queues

  • Learn:
    • FIFO (First In First Out)
  • Practice:
    • easy questions

Next 5 days: Recursion

  • Learn:
    • Factorial-style recursion (e.g., factorial(n) calling factorial(n-1) until base case)
  • Practice:
    • easy questions only
    • factorial-type and story-based questions recommended
  • Note:
    • It may be confusing initially—focus on easy problems.

Next: Hashing

  • Learn:
    • Mapping values/keys to uniquely identify elements in large datasets
    • Example: roll number → student name
  • Key benefit:
    • Constant-time lookups (as claimed)
  • Practice:
    • Easy questions using LeetCode/GFG
  • Tip:
    • Hashing can be learned alongside arrays or separately.
    • It appears across multiple data structures.

After Hashing: STL/Library Awareness

  • Learn:
    • STL (Standard Template Library) concepts
  • Goal:
    • Don’t always write everything from scratch—use libraries to save time in competitive programming.
    • Still understand core ideas because STL can be slower in some cases, and understanding improves “brain sharpening.”

Next block: Trees and Tries

  • Suggested method:
    • Learn theory first (types, terminology, visualization), then code
  • Trees:
    • Hierarchical structure with root, nodes, children, edges, leaves
  • Tries:
    • Specialized tree for storing strings
    • Used for fast retrieval, autocomplete, spell check, dictionaries

Next 3 days: Heap

  • Learn:
    • Heap as a specialized tree structure with heap property
    • Max heap and min heap
    • Related to complete binary tree
  • Practice:
    • Mainly problems (implied less theory due to prior tree learning)

Next 10 days: Graph

  • Emphasis:
    • Graphs require patience; many questions appear in big-company interviews
  • Learn:
    • Graphs as vertices + edges
    • Example: Google Maps shortest path (graph shortest path concept)
  • Practice:
    • Easy questions on GeeksforGeeks/LeetCode
    • Suggested 10 days, but it can take more

Next: Greedy

  • Learn:
    • Making locally optimal choices to achieve a global optimum
  • Suggested practice:
    • ~2 days for concept
    • Then easy problems using previously learned DS concepts

Next: Dynamic Programming

  • Learn:
    • Break into overlapping subproblems
    • Solve each subproblem once and store results (memoization/tabulation idea)
  • Practice:
    • Mostly problem-solving, starting with easy questions

Next: Backtracking

  • Learn:
    • Build solutions incrementally by exploring choices and undoing when needed
    • Framed with chess analogy (remembering/rolling back moves)
  • Suggested time:
    • ~5 days
  • Practice:
    • easy and medium questions (hard may not appear early in backtracking-easy sets)

Final block mentioned: Strings (intentionally placed later)

  • Suggested time:
    • 4 additional days
  • Learn:
    • Strings as sequences of characters
  • Practice:
    • Easy string problems are easier after arrays knowledge
    • Do medium string questions for broader company coverage

After Topics: Remaining Practice Time (about 30 days)

  • As phrased:
    • “proper 13 days remaining”
    • total “30 days for solving medium level problems”
  • Strategy:
    • Solve at least 5 medium problems
    • Prefer 3–5 medium problems minimum for better ranking
    • Move to hard only when medium is comfortable

Guidance on Placement/Interviews (what he claims matters most)

  • Doing medium-level problems well may be enough to aim for Google interviews.
  • Why many people don’t get placed:
    • Doing too many problems, but not the exact right ones
    • Copying/pasting hint solutions instead of actually solving
  • Recommended approach:
    • Use curated “sheets” from successful interview candidates
    • Solve a limited number of targeted questions

Sources / Speakers (Identified)

  • Harshal Jain — mentor at GeeksforGeeks (main speaker in the subtitles)
  • Sandeep Jain — referenced as the educator/owner associated with GeeksforGeeks courses (not speaking)
  • GeeksforGeeks — course platform and “390 challenge” referenced
  • ChatGPT — mentioned as a tool for generating logic or writing algorithms (not a speaker)

Original video