DSA Roadmap for Beginners: What to Learn and in Which Order
10 Nov 2026, 07:33 am

A good DSA roadmap for beginners starts with one programming language, then complexity analysis, then arrays, strings and hashing, and only after that moves to linked lists, stacks, queues, recursion, trees and graphs. Sorting, searching, dynamic programming, greedy methods and backtracking come last because they lean on everything before them. Follow the order below and you will rarely hit a topic that assumes something you have not yet seen.
The roadmap is the same whether you are a first year student starting early or a working professional preparing for a job switch. What changes is the pace. A student with a free evening can spend a week on each stage, while someone with a full time job may need two.
The roadmap at a glance
Stage | Topic | What to practise | Move on when |
|---|---|---|---|
1 | Language basics | Loops, functions, lists, dictionaries, input and output | You can write a small program without looking up syntax |
2 | Complexity analysis | Counting operations, reading O(n) and O(n squared) in code | You can state the cost of your own solution |
3 | Arrays and strings | Two pointers, sliding window, prefix sums | You solve easy problems without hints |
4 | Hashing | Frequency counts, two sum, grouping anagrams | You reach for a hash map on purpose |
5 | Linked lists | Reversal, cycle detection, merging | You can draw pointer changes on paper |
6 | Stacks and queues | Balanced brackets, next greater element, level order traversal | You can explain why each structure fits |
7 | Recursion | Factorial, subsets, tracing the call stack | You can name the base case first |
8 | Trees | Traversals, height, binary search trees | You write traversals from memory |
9 | Graphs | BFS, DFS, connected components, shortest path basics | You model a grid or a network as a graph |
10 | Sorting and searching | Merge sort, quick sort ideas, binary search on answers | You can justify the cost of each method |
11 | Dynamic programming | Fibonacci, knapsack style problems, grids | You can write the recurrence before the code |
12 | Greedy and backtracking | Interval scheduling, permutations, N queens | You can tell when greedy fails |
Stages one and two: the foundation people skip
Pick one language and stay with it. Python is a common choice because it keeps syntax out of the way, and a Python tutor can help if loops and dictionaries still feel shaky. C++ and Java are equally valid, especially if your college or target role uses them. Switching languages halfway costs more time than any difference between them saves.
Complexity analysis is simply the habit of asking how the work grows as the input grows. If you check every pair of numbers in a list with a nested loop, the work grows like O(n squared). Ten items mean about a hundred checks, a thousand items mean about a million. Binary search on a sorted list is O(log n), because each step halves what remains. Spend a few days on this, because every later topic gets judged by it.
Stages three and four: arrays, strings and hashing
Most interview questions live here, so this is where practice pays back fastest. Learn two pointers (one at each end of a sorted list), the sliding window (a moving range over a string or list) and prefix sums (running totals that answer range questions quickly).
Then meet hashing through the classic two sum problem. The slow approach checks every pair in O(n squared). The better one walks through the list once, and for each number asks a hash map whether its partner has already been seen. That brings it to O(n) time at the cost of O(n) extra space. This trade of memory for speed shows up again and again.
Solve ten to fifteen easy problems per topic before moving on.
Write the brute force first, state its cost, then improve it.
Redo any problem you needed a hint for after three days.
Stages five to seven: pointers, stacks, queues and recursion
Linked lists feel awkward because you cannot jump to an index. Draw boxes and arrows, and move one pointer at a time. Reversing a list and detecting a cycle with a slow and a fast pointer are the two exercises worth repeating until they feel boring.
Stacks follow last in, first out, and queues follow first in, first out. Checking whether brackets in a string are balanced is the natural stack exercise, and level by level tree traversal is the natural queue exercise. Recursion comes next because trees and graphs depend on it. Trace a small call, such as computing a factorial of four, and write down what sits on the call stack at each moment.
Stages eight and nine: trees and graphs
A tree is a linked structure where each node has children, and nearly every tree problem is a recursion problem in disguise. Learn the three depth first orders (preorder, inorder, postorder), level order traversal, and how a binary search tree keeps smaller values on the left.
Graphs are trees without the rules. Learn to store one as an adjacency list, then practise breadth first search for shortest paths in unweighted graphs and depth first search for exploring everything reachable. A grid of cells, such as counting islands in a map, is a graph problem wearing a costume.
Stages ten to twelve: the harder techniques
By now sorting should feel familiar. Understand merge sort well, because it teaches divide and conquer, and know why a typical good sort costs O(n log n). Binary search deserves extra time, since it also works on answers, such as finding the smallest capacity that lets a task finish in time.
Dynamic programming is recursion plus memory. Start with Fibonacci, notice the repeated calls, and store results to cut the cost from exponential to O(n). Then try grid paths and knapsack style questions. Greedy methods make the choice that looks right at that moment, and you must learn to spot when that choice breaks, which is why practising counter examples helps. Backtracking explores choices and undoes them, as in generating permutations.
How to practise at every stage
Reading solutions is not practice. Try each problem for twenty to thirty minutes, then look at a hint, then a full solution only if needed, and finally write the solution again from scratch the next day. Keep a short notebook of patterns, such as "sorted input suggests two pointers or binary search". Online coding practice sites are enough for problems, so you rarely need to pay for a collection.
If you would rather have someone check your reasoning, compare the options of a tutor, a bootcamp and self study to see which suits your schedule. If you have a fixed timeline, the twelve week DSA plan maps these stages to weeks.
Where a tutor can help, and where they cannot
A tutor can notice that you keep misreading problem statements, or that your pointer drawings are skipping a step. That kind of feedback is hard to get from a video. A tutor cannot learn the material for you, and no roadmap guarantees an outcome. Progress comes from steady problem solving.
When you are ready to talk to someone, browse DSA tutors on FindMyGuru, compare profiles, and contact the ones whose experience fits your stage. Classes and fees are arranged directly with the tutor.