Blog
The interview bar shifts from "can you code" to "can you solve complex structural problems efficiently." At 1-3 years of experience, grinding easy array problems yields diminishing returns, while mastery of trees, graphs, and dynamic programming becomes the primary differentiator.
Fresher interviews often test basic syntax and linear data structures because the candidate has limited exposure to system complexity. Recruiters assume a junior engineer will struggle with recursion or pointer manipulation, so they start with two-pointer array questions or simple stack operations.
Once you have two years of experience, that assumption vanishes. You are expected to have internalized basic patterns. If you still need to think hard about how to reverse a linked list or find the maximum in a sliding window, it signals a gap in foundational fluency. The interviewer moves quickly to topics that require deeper logical structuring. They are not testing if you know what a tree is; they are testing if you can navigate a non-linear structure under time pressure.
The core change is speed and depth. A fresher might take 15 minutes to set up a BFS for a graph. An experienced candidate should recognize the pattern in 2 minutes and spend the remaining time on edge cases and optimization. The "easy" problems are no longer the filter; they are the warm-up. The real filter is the medium-to-hard problems that involve state management or complex traversal.
Not all DSA topics carry equal weight at this stage. You need to triage your study time based on probability of appearance and difficulty of execution.
High Priority: Trees and Graphs These are the most common topics for mid-level interviews. Binary Search Trees, Lowest Common Ancestor, and Tree Serialization are standard. For graphs, expect BFS/DFS variations, Topological Sort, and Dijkstra’s algorithm. The key here is not just memorizing the code, but understanding when to use a queue versus a stack, or how to handle cycles. If you can solve "Course Schedule" or "Number of Islands" without hesitation, you are on the right track.
High Priority: Dynamic Programming DP is the biggest hurdle for many experienced candidates. It is not about memorizing 50 different DP problems. It is about recognizing the pattern: overlapping subproblems and optimal substructure. Focus on the core patterns: 1D DP (Climbing Stairs, House Robber), 2D DP (Longest Common Subsequence, Edit Distance), and Knapsack variants. If you can derive the recurrence relation from scratch, you can solve most DP problems. If you rely on memorized solutions, you will fail when the interviewer tweaks the constraints.
Medium Priority: Heaps and Sliding Window These are frequent but less conceptually dense than DP. Max/Min Heap problems (Top K Elements, Merge K Sorted Lists) and Sliding Window (Maximum Sum Subarray of Size K) are standard. These problems test your ability to optimize time complexity from O(N^2) to O(N log N) or O(N). They are often used as the first or second problem in a round to gauge your baseline efficiency.
Low Priority: Basic Arrays and Strings You have likely solved hundreds of these. Do not waste time re-practicing "Two Sum" or "Valid Anagram" unless you are rusty. These are only relevant if you are struggling with the basics. For an experienced candidate, these should be solved in under 5 minutes. If they take longer, your problem-solving speed is the issue, not the topic.
A common mistake is focusing only on correctness. In a 45-minute interview, you have roughly 35 minutes for the first problem. If you spend 20 minutes writing a brute-force solution and then 15 minutes trying to optimize it, you fail. The expectation is to identify the optimal approach within the first 5-10 minutes.
This requires pattern recognition. When you see a problem asking for the "k-th smallest," you should immediately think of a Heap or QuickSelect. When you see "shortest path," you should think of BFS or Dijkstra. This recognition comes from solving enough problems to see the underlying structures, not from reading tutorials.
Stop solving random easy problems. Pick one medium-difficulty graph problem, such as "Clone Graph" or "Word Ladder," and solve it without looking at the solution. Time yourself. If you cannot derive the BFS approach in 10 minutes, review your understanding of queue-based traversal. Then, move to a DP problem like "Coin Change" and focus on deriving the state transition. This targeted practice will reveal your actual gaps faster than grinding through a list of 100 easy arrays.
Striver, Love Babbar and Apna College disagree on the order and overlap on 75 problems. Here is what happens when you merge all three into one 370-problem sheet and let the target role decide the order.
A frontend loop asks less DSA than a backend loop and a different slice of it: 6 core topics, 84 problems. Here they are in the order to practise them in JavaScript, plus the language details that cost people offers.
