The DSA Roadmap for Placements: What to Study and What to Skip
Gokul
· 5 min read

Ask ten students how to prepare DSA for placements and you will get ten different lists, and most of them end with “solve 500 problems.” That advice sounds hard-working and works badly. Placement tests do not ask for everything in a DSA textbook. They ask for a fairly small set of topics, again and again. This post ranks those topics, tells you what to skip for now, and gives a 60-day plan you can start today.
In short: learn arrays, strings and hashing first, then linked lists, stacks, queues, trees and basic DP, and leave advanced topics for later. Aim for about 150 problems you actually understand, not 500 you half remember.
Why “Solve Everything” Fails
Grinding random problems feels productive, but three things go wrong. You spend weeks on topics that rarely appear in your target tests. You solve a problem once, forget it, and cannot repeat it under time pressure. And you never learn the patterns that let you solve problems you have not seen. A roadmap fixes the first problem by ordering topics, and a review habit fixes the other two.
What to Study, in Order
These tiers are a practical guide based on the topics that commonly appear in online assessments and interviews. They are not exact statistics, and product companies lean harder on Tier 2 and Tier 3 than service companies do.

Tier 1 is where most coding tests are won. A typical Tier 1 problem looks like this: instead of two nested loops over the array, one pass with a hash map does the job.
def two_sum(nums, target):
seen = {} # value -> index
for i, x in enumerate(nums):
if target - x in seen:
return [seen[target - x], i]
seen[x] = i
print(two_sum([2, 7, 11, 15], 9)) # [0, 1]The nested-loop version takes O(n²) time. This one takes O(n). Spotting that kind of improvement is most of what coding tests are measuring.
What to Skip for Now
Segment trees, advanced graph algorithms such as max flow, advanced string algorithms and competitive-programming math are rarely needed for placements. Skip them until Tiers 1 to 3 feel comfortable. If you are targeting top product companies, add them back later, not first.
A 60-Day Plan

Days 1 to 15, foundations: arrays, strings, hashing, basic math and sorting. Learn two pointers and sliding window here.
Days 16 to 35, core structures: linked lists, stacks, queues, binary search and recursion.
Days 36 to 50, trees and more: trees (BFS, DFS, BST), greedy, 1D dynamic programming and graph basics.
Days 51 to 60, mocks and revision: timed full-length tests, plus a second pass over problems you got wrong.
Pace yourself at about 2 to 3 problems a day, with one timed mock on weekends. Pick one language (C, C++, Java or Python are accepted by most company tests) and stay with it.
How Many Problems Are Enough?
As a rule of thumb, about 150 well-understood problems is a solid target for service-company tests and many mid-tier product roles. Top product companies usually expect more, but the same roadmap applies. A reasonable split:
Arrays and strings: 35
Hashing: 15
Sorting and binary search: 20
Linked lists, stacks and queues: 20
Recursion and backtracking basics: 10
Trees: 20
Graphs: 10
Dynamic programming and greedy: 20
How to Solve a Problem the Right Way
Try for 20 to 30 minutes before looking at anything. Write down the brute-force idea even if it is slow.
Read one solution, then close it and code it yourself from scratch.
Name the pattern in one line, for example “sliding window” or “hash map for lookup.”
Revisit it after one day and again after a week, without help.
Note the time complexity of your final solution. Interviewers always ask.
Free Resources
LeetCode: free problems with topic tags, and a large library of discussion solutions.
GeeksforGeeks Practice: topic-wise problems with company tags.
HackerRank: many companies use it for their online assessments, so the interface is worth knowing.
NeetCode: a curated problem list with video explanations, organised by pattern.
takeUforward: a popular free DSA sheet that follows a topic-wise order.
Common Mistakes to Avoid
Jumping to advanced topics before arrays, strings and hashing are solid.
Counting problems solved instead of problems understood.
Reading solutions too early, before giving the problem a real attempt.
Switching languages or resources every week.
Never practicing in a timed, no-hints setting before the real test.
Key Takeaways
Study in tiers: arrays, strings and hashing first, then linked lists, stacks, queues, trees and basic DP.
Skip segment trees and other advanced topics until the basics are comfortable.
Plan for about 60 days and about 150 problems you can solve again without help.
Review beats volume. Revisit each problem after a day and after a week.
Finish with timed mocks, because speed under pressure is a skill of its own.
Check Your DSA Readiness
A roadmap tells you what to practice. A timed test tells you how you perform under pressure. Take a timed skill test on Skillrank to find your weak areas before the real assessment.