All roadmaps

Data Structures & Algorithms

The interview gate - and the engineering foundation.

Complexity analysis, the core data structures, the essential algorithms and the problem-solving patterns that unlock coding interviews at product companies.

Your progress0/35 topics · 0%

Progress is saved in this browser.

5 stages35 topics₹0 to follow
Skill certification coming soon

Filled nodes are the focus for this track; outlined ones can wait. Tap a topic to open it and mark it done, learning or skipped.

Data Structures & Algorithms in 2026Related roadmapsSystem Design roadmapPython roadmapJava roadmapProve it as you goReading is half of it. The free, scoredSoftware Engineer certification coversthe ground this roadmap leads to, and theFull-Stack Engineer job simulation putsit to work on real tickets - evidence arecruiter can check. Mark topics done,learning or skipped as you go; yourprogress carries into the classic view.Software Engineer certificationJob simulationClassic viewKnow the demand before thesyntaxData Structures & Algorithms in2026What to learn in 2026Big-O andarraysTrees, graphs,DPDSA with AI assistantsWhich roles use itProduct-companyhiringBeyond theinterviewFresher vs switcherWhat companies expectThe hiring barWhat interviewstestProof they verifyWhat gets you hiredA 90-day planProjects thatget readCertification and proofMeasure before you optimise.FoundationsBig-O analysisArrays & stringsHash maps & setsLists, stacks and queues,instinctively.Linear StructuresLinked listsStacks & queuesTwo pointers & slidingwindowHierarchies and networks.Trees & GraphsBinary trees & BSTsGraphsHeaps & priority queuesTries (awareness)The toolkit for hard questions.Algorithms & PatternsSorting & binary searchRecursion & backtrackingDynamic programming (intro)Practice strategyFresher or experienced?Both tracks hold every topic. On the Fresher track thefoundations are filled and the later stages are outlined - dothem when a project needs them. On the Experienced track thefoundations are outlined and the later stages are filled. The2026 section at the top applies to both.Prefer a list?The classic view shows the same 4 stages as a sequentialchecklist with time estimates. Your marks are shared betweenthe two views.Open the classic view

Everything on this roadmap

Every stage and topic on the map, in reading order. Click any topic to open it.

1.Know the demand before the syntax

2.Measure before you optimise.

3.Lists, stacks and queues, instinctively.

4.Hierarchies and networks.

5.The toolkit for hard questions.

The Data Structures & Algorithms roadmap, topic by topic

Every topic on the map in reading order, with what to learn and the resources we recommend. Main topics are open; open any subtopic to read it. Select a topic name to open it in the topic panel, where you can track your progress.

  1. 1. Know the demand before the syntax

    Data Structures & Algorithms in 2026

    2026

    Data structures and algorithms are still the entry test at most product companies and the language in which engineers reason about performance, even as hiring shifts toward practical work. HackerRank's 2025 Developer Skills Report found 66 percent of developers preferring real-world assessments and reported that practical coding tests have become the standard - but it also found 74 percent of developers struggling to land a job and early-career hiring hit hardest, which is why the algorithms round still decides offers for freshers. The four nodes answer what to learn, which roles use it, what companies expect and what gets you hired.

    What to learn in 2026

    Learn complexity and the linear structures until they are reflex, then trees, graphs and dynamic programming to the level interviews ask, and then how to practise with AI assistants without letting them do the thinking. The sub-nodes order the three.

    Big-O and arrays

    Big-O as a way of thinking, then arrays, strings, hash maps, sets, stacks, queues, linked lists, two pointers, sliding windows, prefix sums, sorting and binary search - the structures and techniques behind most interview questions and most real performance problems. HackerRank's 2025 report says practical assessments are now the standard, but the screening round at large product companies still starts here, in your main language. Practise until the pattern is recognised in the first minute: that is what a timed round measures.

    Trees, graphs, DP

    Trees and their traversals, binary search trees, heaps and priority queues, tries, graphs with breadth-first and depth-first search, shortest paths and topological order, recursion and backtracking, and dynamic programming built up from memoisation. These are what the on-site rounds at product companies ask, and they are also the structures behind search indexes, schedulers, routing and dependency resolution in real systems. Learn each with two classic problems and one real use, so the interview answer and the engineering judgement are the same knowledge. HackerRank's 2025 report found 74 percent of developers struggling to land a job; the on-site rounds are where the offers are decided.

    DSA with AI assistants

    AI

    AI assistants solve standard algorithm problems instantly, which changed the point of practising them: the goal is no longer to have the solution but to recognise it, explain it and know when it is wrong. The Stack Overflow 2025 survey has 80 percent of developers using AI tools and 46 percent distrusting their accuracy; HackerRank's 2025 report describes assessments moving to practical tasks partly for this reason. Practise with the assistant as a tutor - explain your approach first, ask it to critique, then write the code yourself - and never in the interview itself unless invited.

    Which roles use it

    Product-company interviews are where DSA is tested most; the skill then lives on in every engineer's judgement about performance. The sub-nodes cover both and the fresher and switcher routes.

    Product-company hiring

    Large product companies, the global capability centres of foreign technology firms and most well-funded startups screen with algorithm rounds, especially for freshers and early-career engineers, and the on-site adds system design and practical rounds. HackerRank's 2025 report found 74 percent of developers struggling to land a job with juniors hit hardest, so for a fresher the round is the gate to the best-paying roles. Services companies and smaller product teams weight practical work more; know which kind of company you are applying to.

    Beyond the interview

    Beyond the interview, the skill is engineering judgement: choosing a hash map over a list, seeing the quadratic loop, knowing why a queue beats a poll, estimating whether a feature will survive ten times the data. Senior engineers rarely implement a red-black tree, but they read a query plan, a profiler and a design document with these structures in mind. The System Design roadmap is where this knowledge becomes architecture. GitHub's Octoverse 2025 counts more than 180 million developers; the ones who get promoted are the ones who read a profiler with these structures in mind.

    Fresher vs switcher

    A fresher targeting product companies should treat DSA as a daily practice for three months alongside one real project; HackerRank's 2025 report is clear that the practical project is now equally examined, so neither alone is enough. A switcher from another field or an experienced engineer returning to interviews needs weeks, not months, of pattern review. On this map freshers get the fundamentals filled and the advanced stages outlined; experienced learners get the reverse.

    What companies expect

    Companies that test DSA expect a correct, efficient solution explained clearly under time pressure - and increasingly a practical problem alongside it. The sub-nodes cover the bar, the interview and what gets verified.

    The hiring bar

    The bar in an algorithms round is a correct solution with the right complexity, written cleanly in a real language, explained as you go, tested on an edge case, and improved when the interviewer pushes. In 2026 that round sits beside a practical task; HackerRank's 2025 report says 66 percent of developers prefer the practical one and companies have made it standard. The Work Trend Index's 66 percent of leaders who will not hire without AI skills applies to the practical round, not the algorithm one - there you are on your own.

    What interviews test

    Expect one or two timed problems on arrays, strings, maps, trees or graphs in an online screen, then on-site rounds that add a harder problem, a practical build or debugging task and, for mid-level and above, system design. The interviewer is assessing how you think out loud, whether you test, and how you respond to a hint. A brute-force answer explained well and then improved beats silence followed by an optimal one.

    Proof they verify

    Hiring teams verify DSA in the room, not on a profile, so the proof that gets you into the room is the rest: a deployed project, a readable repository and a verified certification in your language - OneRoadmap's Python, Java and JavaScript certifications are free and carry a public verification link. A practice-platform streak is weak evidence; a project that shows you chose the right structure under real constraints is strong. The Stack Overflow 2025 survey keeps JavaScript, Python and Java among the most used languages, so practise in the one your target companies interview in.

    What gets you hired

    Fluency on the standard problems, one real project that shows the judgement behind them, and a verified certification in your language. The sub-nodes give the ninety-day plan, the projects that get read and the proof that counts.

    A 90-day plan

    Month one: complexity and the linear structures with daily timed problems in your main language, explained aloud. Month two: trees, graphs and dynamic programming with two problems a day, plus the real project that shows the judgement. Month three: mixed mock interviews twice a week, a practical build under time, the certification in your language, and twenty targeted applications a week to the companies whose process matches your preparation.

    Projects that get read

    Projects that get read show algorithms doing real work: a search or autocomplete feature with a trie or an index and measured latency; a scheduler or dependency resolver with a topological sort; a route or recommendation feature with a graph; a performance fix in a real codebase with before-and-after numbers. Each has a repository and a readme that names the structure and why. HackerRank's 2025 report says practical work is now examined alongside the puzzle; this is how to show both at once.

    Certification and proof

    Proof is a combination: fluency demonstrated in the round, a project that shows the judgement, a GitHub profile with real history and a verified certification in your language. The candidates who get past the screen are the ones who prepared for both halves of the 2026 interview.

  2. 2. Measure before you optimise.

    Foundations

    Measure before you optimise.

    Time: about 1 week. Topics: Big-O analysis · Arrays & strings · Hash maps & sets.

    Big-O analysis

    Optional on the Experienced track

    Time and space complexity, best/worst/average cases - the lens every solution is judged through.

    Arrays & strings

    Optional on the Experienced track

    Indexing, in-place operations and common string manipulations - where most easy problems live.

    Hash maps & sets

    Optional on the Experienced track

    O(1) lookups, frequency counting and dedupe - the single most useful interview tool.

  3. 3. Lists, stacks and queues, instinctively.

    Linear Structures

    Lists, stacks and queues, instinctively.

    Time: about 1-2 weeks. Topics: Linked lists · Stacks & queues · Two pointers & sliding window.

    Linked lists

    Traversal, reversal and the fast/slow pointer trick - pointer manipulation as a skill.

    Stacks & queues

    LIFO/FIFO, monotonic stacks and BFS's best friend - recognising 'this is a stack problem'.

    Two pointers & sliding window

    The pattern pair behind a huge share of array/string mediums.

  4. 4. Hierarchies and networks.

    Trees & Graphs

    Hierarchies and networks.

    Time: about 2-3 weeks. Topics: Binary trees & BSTs · Graphs · Heaps & priority queues · Tries (awareness).

    Binary trees & BSTs

    Traversals (DFS orders, BFS), depth/height and the BST invariant - recursion's home turf.

    Graphs

    Adjacency representations, BFS/DFS, connected components and cycle detection.

    Heaps & priority queues

    Top-K problems and efficient min/max access - the structure behind schedulers.

    Tries (awareness)

    Prefix trees for autocomplete-shaped problems.

  5. 5. The toolkit for hard questions.

    Algorithms & Patterns

    The toolkit for hard questions.

    Time: about 2-3 weeks. Topics: Sorting & binary search · Recursion & backtracking · Dynamic programming (intro) · Practice strategy.

    Recursion & backtracking

    Optional on the Fresher track

    Choose → explore → unchoose: permutations, combinations and constraint problems.

    Dynamic programming (intro)

    Optional on the Fresher track

    Overlapping subproblems, memoisation and the classic 1D/2D patterns - feared, learnable.

    Practice strategy

    Optional on the Fresher track

    Spaced repetition by pattern, timed sets and post-mortems - practising like it's a sport.

Prove it as you go

Reading is half of it. The free, scored Software Engineer certification covers the ground this roadmap leads to, and the Full-Stack Engineer job simulation puts it to work on real tickets - evidence a recruiter can check. Mark topics done, learning or skipped as you go; your progress carries into the classic view.

Fresher or experienced?

Both tracks hold every topic. On the Fresher track the foundations are filled and the later stages are outlined - do them when a project needs them. On the Experienced track the foundations are outlined and the later stages are filled. The 2026 section at the top applies to both.

Prefer a list?

The classic view shows the same 4 stages as a sequential checklist with time estimates. Your marks are shared between the two views.

Frequently asked questions

Are data structures and algorithms still tested in 2026?

Yes, at most product companies, the global capability centres of foreign technology firms and well-funded startups - especially for freshers. HackerRank's 2025 report found practical assessments becoming the standard alongside, not instead of, the algorithms round, and 74 percent of developers struggling to land a job, with juniors hit hardest.

Which language should I practise in?

The one your target companies interview in and the one you will use at work: Python, JavaScript or Java for most. The Stack Overflow 2025 survey keeps all three among the most used languages. Switching languages mid-preparation costs weeks; pick one and stay fluent in it.

How much DSA do I need for a job?

Complexity, arrays, strings, hash maps, two pointers, sliding windows, sorting and binary search as reflexes; trees, graphs, heaps, recursion and dynamic programming to the level on-site rounds ask. Beyond the interview, the skill is engineering judgement - choosing a hash map over a list, seeing the quadratic loop.

Is it enough to solve a lot of problems?

No. HackerRank's 2025 report says practical, explained work is now examined alongside the puzzle, and the interview assesses how you think aloud, test and respond to hints. Practise problems daily and build one real project that shows the judgement; neither alone gets the offer.

Should I use AI assistants to practise?

As a tutor, not a solver: explain your approach first, ask it to critique, then write the code yourself. Assistants solve standard problems instantly, which is why interviews moved toward recognising, explaining and knowing when a solution is wrong. Never in the interview itself unless invited.

How long does it take to prepare?

A fresher targeting product companies should plan three months of daily practice alongside a real project; an experienced engineer returning to interviews needs weeks of pattern review. Nobody can promise a timeline. Mock interviews with a person are the best measure of readiness.

Will AI make DSA skills obsolete?

It made having the solution obsolete and left recognising, explaining and verifying it. Senior engineers rarely implement a balanced tree, but they read a profiler, a query plan and a design document with these structures in mind, and the assistant's suggestions with the same eye. The interview still tests that eye.

How do I prove DSA skills without job experience?

Fluency is proved in the room; what gets you into the room is a project that shows the judgement - a search feature with a trie and measured latency, a scheduler with a topological sort, a performance fix with before-and-after numbers - plus a GitHub profile with real history and OneRoadmap's free certification in your language.