Campus Placement DSA Roadmap 2026 - What to Study and in What Order

Key Takeaways

• Campus rounds test a narrow, predictable band of DSA — far less than a full competitive programming syllabus.
• Order matters: arrays and strings first, because they carry the largest share of questions.
• 150-250 well-understood problems beats 500 skimmed, and revision is what makes the difference.
• Learn patterns rather than problems, because unfamiliar questions are familiar patterns in new clothing.
• Skip the advanced topics — segment trees and heavy graph algorithms rarely appear in campus rounds.

Most DSA preparation fails not from lack of effort but from lack of order. Students solve problems randomly across topics, never revise, and arrive at placement season having seen four hundred problems and retained the patterns from none.

The syllabus for campus rounds is genuinely narrow and genuinely learnable in a few months of structured work.

This guide is that structure.

While you prepare, make sure your resume clears screening — the free ATS score checker.

The order to learn in

Sequenced by how much of the question bank each topic covers, so early effort pays fastest.

Month 1: Foundations

One language, properly. C++, Java or Python. Depth in one beats familiarity with three.

Arrays. Traversal, two pointers, prefix sums, sliding window, in-place manipulation. The single largest category in campus rounds.

Strings. Palindromes, anagrams, substrings, frequency counting, basic manipulation.

Time and space complexity. Not as theory — as the habit of stating the complexity of everything you write.

By the end of month one you should be solving easy problems without fighting the syntax.

Month 2: Core structures

Hashing. Hash maps and sets for frequency, duplicates and lookup. This single topic converts a large number of nested-loop problems from quadratic to linear, and interviewers explicitly look for it.

Searching and sorting. Binary search, including on rotated arrays and on answer spaces. Sorting as a preprocessing step.

Linked lists. Reversal, cycle detection, finding the middle, merging, removing the nth node. A small topic with a fixed set of recurring questions.

Stacks and queues. Balanced parentheses, next greater element, monotonic stack.

Month 3: Recursion and trees

Recursion. Understand the recursion tree rather than memorising templates.

Backtracking. Subsets, permutations, N-queens, grid paths.

Trees. Traversals, height, diameter, BST operations, lowest common ancestor, checking balance and symmetry. Recursion fluency matters more here than anything else.

Month 4: The remaining ground

Dynamic programming, at the easier end — Fibonacci variants, climbing stairs, house robber, coin change, longest common subsequence, 0/1 knapsack. Learn the memoisation-to-tabulation progression on a handful of classics rather than attempting the whole topic.

Graphs. BFS, DFS, connected components, cycle detection, simple shortest path. More common at product companies than service-based ones.

Number theory basics. Primes and sieve, GCD and LCM, digit manipulation.

Ongoing: timed practice

Contests and mock tests under real time pressure. This is a separate skill from untimed solving and it is the one tested on the day.

What to skip

Explicitly, because time spent here is time not spent on what actually appears:

• Segment trees and Fenwick trees
• Advanced graph algorithms — max flow, strongly connected components
• Heavy number theory
• String algorithms like KMP and suffix structures
• Advanced DP — bitmask, digit DP

A small number of top product companies go further, but for the overwhelming majority of campus rounds these do not appear. Check what your target companies actually asked last year — placement cells frequently keep records, and it is the most underused resource on campus.

Volume and revision

150 to 250 well-understood problems is enough for campus rounds. Understood means you could re-solve it in a week without looking.

Revision is what separates outcomes. Re-solve problems you got wrong after a week, then after a month. Spaced repetition applies to coding exactly as to anything else, and skipping it is why students forget patterns they "already did".

Keep a pattern log, not a problem count. For each problem write which pattern it was — two pointers, sliding window, monotonic stack. Within weeks you start recognising shapes rather than recalling solutions, which is the entire skill the round tests.

A reasonable weekly rhythm: 8-10 new problems, 3-4 revisions, one timed session.

Adjusting by target

Service-based companies ask easy to easy-medium — arrays, strings, basic logic. Aptitude carries more weight than DSA depth, so balance accordingly — see the campus placement aptitude test guide and service-based vs product-based companies.

Product companies ask medium difficulty with optimal complexity expected, and graphs and DP appear more often.

If you are starting late, prioritise arrays, strings, hashing and binary search. They cover a disproportionate share of easy and easy-medium questions.

The full round mechanics are in the campus placement coding round guide.

Common Mistakes

Solving randomly across topics. Without order you never build depth in the areas that carry the most questions.

Counting problems instead of logging patterns. The count is not the skill; recognising which pattern a new problem belongs to is.

Never revising. Patterns fade, and students routinely forget material they solved two months earlier.

Studying advanced topics that do not appear. Segment trees and max flow are time taken from arrays and hashing.

Practising only untimed. Time pressure changes performance substantially and is its own skill.

Learning multiple languages simultaneously. Depth in one is what campus rounds reward.

Skipping complexity analysis. Stating time and space for everything you write is a habit interviewers explicitly assess.

Neglecting aptitude while grinding DSA. For many companies aptitude eliminates you before the coding round.

Frequently Asked Questions

How many problems should I solve?

150 to 250 that you genuinely understand and could re-solve. Depth and pattern recognition matter far more than raw count.

Which topics matter most?

Arrays, strings, hashing and binary search carry the largest share of campus questions. Trees, recursion and basic DP follow.

Which language should I use?

Whichever you know best. C++ for its standard library and speed, Java widely accepted, Python fine for most campus rounds though slower on tight limits.

Do I need advanced topics?

Rarely. Segment trees, advanced graph algorithms and heavy DP variants seldom appear in campus rounds outside a few top product companies.

How long does the roadmap take?

Roughly four months of consistent work at 8-10 new problems and a few revisions weekly, plus ongoing timed practice.

How do I make patterns stick?

Log the pattern for every problem you solve, and re-solve wrong answers after a week and again after a month.

What if placements are next month?

Prioritise arrays, strings, hashing and binary search, do timed mocks immediately, and target companies that weight aptitude more heavily than DSA depth.

DSA only matters if your resume gets you into the drive. Check your ATS score free.

Make This Practical

Follow the order rather than solving randomly. Arrays and strings first because they carry the largest share of questions, then hashing and binary search, then recursion and trees, then basic DP and graphs. Early effort in that sequence pays fastest.

Then change what you track. Log the pattern for every problem — two pointers, sliding window, monotonic stack — instead of counting problems solved. Recognising shapes is the skill; the count is not.

Finally, build revision into the week. Eight to ten new problems, three to four re-solves of things you previously got wrong, and one timed session — because patterns fade without spaced repetition, and time pressure is a separate skill from knowing the answer.