Here's a proven 16-week roadmap to take you from beginner to placement-ready. Each phase builds on the previous one — don't skip ahead.

Phase 1 — Programming Fundamentals (Week 1–2)

Before touching DSA, make sure your basics are rock solid. If these feel shaky, DSA will feel impossible.

• Variables, Data Types, and Operators
• Conditional Statements (if-else, switch)
• Loops — for, while, do-while
• Functions — parameters, return types, scope
• Basic input/output handling
• Introduction to Arrays

Goal for this phase: Solve 25–30 easy problems on platforms like HackerRank, EduCrush, or LeetCode. Focus on getting comfortable with writing code, not on solving hard problems.

Phase 2 — Core Data Structures (Week 3–6)

This is where DSA truly begins. Take your time here — these are the building blocks of everything that follows.

Arrays — The most fundamental data structure. Focus on:

• Linear Search and Binary Search
• Two Pointer technique
• Sliding Window approach
• Prefix Sum arrays

Strings — Used in almost every real-world application:

• String traversal and manipulation
• Palindrome and Anagram problems
• Substring search basics

Linked List — Teaches you how memory and pointers actually work:

• Singly Linked List — insertion, deletion, traversal
• Doubly Linked List
• Reversing a Linked List (a classic interview question)
• Detecting cycles in a Linked List

Stack — Last In, First Out (LIFO) structure:

• Push, Pop, Peek operations
• Valid Parentheses problem
• Next Greater Element
• Implementing a stack using arrays and linked lists

Queue — First In, First Out (FIFO) structure:

• Enqueue and Dequeue operations
• Circular Queue
• Deque (Double Ended Queue)

Important: For each topic, solve at least 10–15 problems before moving on. Theory without practice is useless in DSA.

Phase 3 — Intermediate Concepts (Week 7–10)

Once you're comfortable with Phase 2, move into more complex territory.

Trees — One of the most important topics for interviews:

• Binary Tree — Inorder, Preorder, Postorder traversals
• Binary Search Tree (BST) — insertion, search, deletion
• Height, Diameter, and Level Order Traversal
• Lowest Common Ancestor (LCA)

Recursion and Backtracking — A mindset shift that unlocks many problems:

• Understanding the call stack visually
• Subsets and Permutations generation
• N-Queens Problem
• Sudoku Solver

Sorting Algorithms — Essential for understanding time complexity:

• Bubble Sort, Insertion Sort, Selection Sort — understand, don't memorize
• Merge Sort and Quick Sort — these are the important ones
• Why O(n log n) is significantly better than O(n²)

Searching — Binary Search goes much deeper than you think:

• Binary Search on sorted arrays
• Binary Search on the answer (a powerful pattern)
• Search in rotated sorted array

Phase 4 — Advanced Topics (Week 11–16)

This is where you separate yourself from the average candidate. These topics take time, but they're worth it.

Graphs — Represents networks, maps, social connections:

• Graph representation — Adjacency List vs Adjacency Matrix
• BFS (Breadth First Search) and DFS (Depth First Search)
• Shortest Path — Dijkstra's Algorithm
• Minimum Spanning Tree — Prim's and Kruskal's
• Cycle detection in directed and undirected graphs

Dynamic Programming (DP) — The most feared and most rewarding topic:

• Understanding overlapping subproblems and optimal substructure
• Memoization (Top-Down) vs Tabulation (Bottom-Up)
• Classic problems: Fibonacci, 0/1 Knapsack, Longest Common Subsequence, Longest Increasing Subsequence
• Grid DP, String DP, Partition DP

Pro tip for DP: Always start by writing a recursive solution first. Once it works, add memoization to optimize it. Then convert to tabulation if needed.

Heaps and Priority Queues — Used in scheduling, graphs, and greedy algorithms:

• Min Heap and Max Heap
• Heap Sort
• Top K elements problems
• Merge K sorted lists

Hashing — Turns O(n) problems into O(1):

• HashMap and HashSet operations
• Two Sum, Three Sum
• Group Anagrams, Subarray with given sum