DSA for coding
interviews in 2027

Data structures and algorithms (DSA) rounds remain the most common technical filter in software hiring, especially at product companies, many global capability centres and in campus placements. Interviewers use them to see how you break down problems, reason about efficiency and write correct code under pressure. Google's own hiring guidance describes coding interviews that assess problem-solving and coding skills.²

The roles DSA unlocks are well paid. AmbitionBox shows typical software engineer pay in India of ₹9.3–10.2 lakh in October 2026, with about 7.4 lakh salaries reported;⁴ in the US, software developers earned a median $135,980 in May 2025.⁵

Typical software engineer pay in India (AmbitionBox, Oct 2026)

₹9.3–10.2 lakh

US median, software developers (BLS, May 2025)

$135,980

Patterns that cover most coding rounds

~12

The complexity you should always state

O(n)

Table: How DSA is tested in software hiring (editorial summary)

MIT's free 6.006 course is a rigorous foundation,¹ and NIST's Dictionary of Algorithms and Data Structures is a reliable reference for definitions.³

def longest_unique(s: str) -> int:
    last_seen = {}
    left = best = 0
    for right, ch in enumerate(s):
        if ch in last_seen and last_seen[ch] >= left:
            left = last_seen[ch] + 1     # move window past the previous occurrence
        last_seen[ch] = right
        best = max(best, right - left + 1)
    return best

How to talk through it: the window [left, right] always contains unique characters; when a repeat appears inside the window, move left just past its previous position. Each index enters and leaves the window once, so time is O(n) and space is O(k) for the character set. Test aloud: "abcabcbb" → 3, "bbbb" → 1, "" → 0, "abba" → 2 (the case that catches the bug when you forget the >= left check).

1. Clarify — Inputs, outputs, sizes, edge cases; restate the problem.
2. Examples — Work one normal and one edge example by hand.
3. Approach — Brute force first, then the better pattern, with complexity for each.
4. Code — Clean, named variables, small helper functions.
5. Test — Walk through examples and edge cases; fix bugs calmly.
6. Complexity and follow-ups — State time and space; discuss variations.

"Two sum."

Hash map of value → index while scanning: O(n) time, O(n) space; mention sorting + two pointers if returning values only.

"Merge overlapping intervals."

Sort by start; merge when the next start ≤ current end. O(n log n).

"Top k frequent elements."

Count with a hash map, then a heap of size k (O(n log k)) or bucket sort (O(n)).

"Detect a cycle in a linked list."

Fast and slow pointers; they meet if there's a cycle.

"Number of islands."

BFS or DFS from each unvisited land cell, marking visited; or union-find.

"Course schedule (can all courses be finished?)."

Topological sort with indegrees (Kahn's algorithm); a cycle means no.

"Coin change (fewest coins)."

DP over amounts: dp[a] = min(dp[a − coin] + 1). O(amount × coins).

"Kth smallest in a BST."

In-order traversal yields sorted order; stop at the kth.

Table: How DSA interviews have changed (editorial summary)

Stack Overflow's 2025 survey found most developers use or plan to use AI tools, yet more distrust their accuracy than trust it.⁶ Interviews have adapted by asking candidates to explain trade-offs, handle variations and debug — skills memorisation can't fake.

1. Pattern sheets — For each pattern, solve five problems and write a one-paragraph summary of when it applies.
2. Spaced repetition — Re-solve problems you got wrong after three and seven days.
3. Mock interviews — Two a week, explaining aloud, with a friend or recorded.
4. Complexity drills — For every solution, write time and space before running it.
5. Edge-case checklist — Empty input, one element, duplicates, negatives, very large inputs.

Table: Roles with DSA rounds and typical pay in India (AmbitionBox, October 2026; indicative)

1. Weeks 1–2: Arrays, strings, hash maps — Two pointers, sliding window, prefix sums.
2. Weeks 3–4: Stacks, queues, linked lists, heaps — Monotonic stacks, top-k.
3. Weeks 5–6: Trees and graphs — Traversals, BFS/DFS, topological sort, union-find.
4. Weeks 7–8: Recursion and DP — Backtracking; classic DP families.
5. Week 9: Prove it — Take the Data Structures and Algorithms Certification and fix weak domains.
6. Week 10: Mocks — Timed mixed sets and mock interviews.

Related: the Software Engineering Interview Readiness test and Technical Problem-Solving assessment; our interview preparation guide covers the rest of the loop.

• Choosing collections — a set instead of a list for membership checks, a map for lookups, a heap for priorities.
• Performance fixes — replacing nested loops on large data with a hash map or sorting step.
• Graph problems — dependencies, routes, permissions and recommendations are often graphs underneath.
• Caching and pagination — understanding the cost of operations at scale.
• Code review — spotting accidental O(n²) behaviour before it reaches production.
• Interviews you run — senior engineers often become the interviewers.

"When would you use a trie?"

For prefix searches such as autocomplete and dictionary lookups, where shared prefixes save time and space.

"What is amortised complexity?"

The average cost per operation over a sequence — appending to a dynamic array is O(1) amortised even though occasional resizes cost O(n).

"How do you choose between BFS and DFS?"

BFS for shortest paths in unweighted graphs and level-by-level exploration; DFS for exhaustive search, cycle detection and topological ordering.

• Coding before clarifying.
• Silence while thinking.
• No complexity analysis.
• Skipping tests of your own code.
• Memorising solutions without understanding patterns.

DSA references are MIT OpenCourseWare's 6.006 and NIST's Dictionary of Algorithms and Data Structures; interview context from Google's hiring guidance; pay from AmbitionBox (read October 2026) and the US Bureau of Labor Statistics; AI-use context from Stack Overflow's 2025 survey. Test formats, the pattern list and the history table are editorial summaries. Science of Apps publishes the free certification linked here. Last reviewed October 2026.

• Big-O — how running time or memory grows with input size.
• Hash map — a structure for fast key–value lookup.
• Heap — a tree-based structure for quickly getting the smallest or largest item.
• BFS / DFS — breadth-first and depth-first ways to explore graphs.
• Dynamic programming — solving problems by combining solutions to overlapping subproblems.
• Sliding window — a technique that maintains a moving range over a sequence.