DSA Interview Prep on Software Engineering Learning Paths

Arrays & Strings

Mon, 01 Jan 0001 00:00:00 +0000

Arrays & Strings#

Arrays and strings are the most common data structures in interviews. Mastering a handful of patterns covers the vast majority of problems.

Pattern Complexity Table#

Pattern	Time	Space	When to Use
Two Pointers	O(n)	O(1)	Sorted array, pair finding, partitioning
Sliding Window	O(n)	O(k)	Subarray/substring with constraint
Prefix Sums	O(n)	O(n)	Range sum queries, subarray sum equals K
Kadane’s Algorithm	O(n)	O(1)	Maximum subarray sum
Sort + Scan	O(n log n)	O(1)	When order doesn’t matter, grouping

Two Pointers#

The two-pointer technique uses two indices that move toward each other (or in the same direction) to solve problems in a single pass.

Hashmaps & Sets

Mon, 01 Jan 0001 00:00:00 +0000

Hashmaps & Sets#

Hash-based structures provide O(1) average-case lookup, making them the first tool to reach for when you need to check existence, count frequencies, or group elements.

Pattern Summary#

Pattern	Time	Space	When to Use
Frequency Counting	O(n)	O(k)	Count occurrences, find duplicates, majority element
Two-Sum (Complement)	O(n)	O(n)	Find pair summing to target (unsorted)
Anagram Detection	O(n)	O(1)*	Compare character frequencies
Grouping	O(n)	O(n)	Group elements by shared property
Set Operations	O(n)	O(n)	Intersection, union, difference

*O(1) space when alphabet is fixed (e.g., 26 lowercase letters).

Linked Lists

Mon, 01 Jan 0001 00:00:00 +0000

Linked Lists#

Linked list problems test pointer manipulation skills. The key insight: most solutions use combinations of just a few core techniques.

Pattern Summary#

Pattern	Time	Space	When to Use
Fast/Slow Pointers	O(n)	O(1)	Cycle detection, middle finding, nth from end
Reversal	O(n)	O(1)	Reverse whole list or sub-section
Merge	O(n + m)	O(1)	Combine sorted lists, interleave
Sentinel Node	O(n)	O(1)	Simplify edge cases (empty list, head deletion)
Runner Technique	O(n)	O(1)	Split list, reorder

Node Definition#

class ListNode:
 def __init__(self, val=0, next=None):
 self.val = val
 self.next = next

Fast/Slow Pointers (Floyd’s Tortoise and Hare)#

Two pointers move at different speeds. The fast pointer moves 2 steps for every 1 step of the slow pointer.

Stacks & Queues

Mon, 01 Jan 0001 00:00:00 +0000

Stacks & Queues#

Stacks (LIFO) and queues (FIFO) appear in problems involving ordering, nesting, and level-by-level processing. The monotonic stack pattern alone covers a large class of interview questions.

Pattern Summary#

Pattern	Time	Space	When to Use
Monotonic Stack	O(n)	O(n)	Next greater/smaller element, histogram
Valid Parentheses	O(n)	O(n)	Matching brackets, nesting validation
Stack as History	O(n)	O(n)	Undo operations, path simplification
Queue with Max/Min	O(n)	O(n)	Sliding window max/min
BFS with Queue	O(V+E)	O(V)	Shortest path, level-order traversal
Deque Patterns	O(n)	O(k)	Sliding window, double-ended access

Monotonic Stack#

A stack that maintains elements in sorted order (increasing or decreasing). As you push elements, you pop anything that violates the monotonic property.

Trees

Mon, 01 Jan 0001 00:00:00 +0000

Trees#

Trees are the most frequently tested data structure in interviews. Most tree problems reduce to choosing the right traversal order and deciding what information to pass up or down the recursion.

Pattern Summary#

Pattern	Time	Space	When to Use
DFS (Recursive)	O(n)	O(h)	Most tree problems — default choice
BFS (Level-order)	O(n)	O(w)	Level-by-level processing, shortest path
BST Operations	O(h)	O(h)	Search, insert, delete, validate
Construction	O(n)	O(n)	Build tree from traversal arrays
Path Problems	O(n)	O(h)	Sum paths, max path, diameter

h = height (log n balanced, n worst case), w = max width

Heaps & Priority Queues

Mon, 01 Jan 0001 00:00:00 +0000

Heaps & Priority Queues#

A heap gives you O(1) access to the min (or max) element and O(log n) insertion/extraction. This makes it the right choice when you repeatedly need the “best” element from a dynamic collection.

Pattern Summary#

Pattern	Time	Space	When to Use
Top-K Elements	O(n log k)	O(k)	K largest/smallest, K most frequent
Merge K Sorted	O(N log k)	O(k)	Combine k sorted sources
Two Heaps (Median)	O(n log n)	O(n)	Running median, stream statistics
Heap + Lazy Delete	O(n log n)	O(n)	Sliding window median, delayed removal
Task Scheduling	O(n log n)	O(n)	Cooldown, interval scheduling

N = total elements, k = number of sources or size constraint

Backtracking

Mon, 01 Jan 0001 00:00:00 +0000

Backtracking#

Backtracking systematically explores all possible solutions by making choices, checking constraints, and undoing choices that lead to dead ends. It’s controlled brute force with pruning.

Pattern Summary#

Problem Type	Time	Space	Pruning Possible?
Permutations	O(n!)	O(n)	Yes (used elements)
Combinations	O(C(n,k))	O(k)	Yes (remaining count)
Subsets	O(2ⁿ)	O(n)	Minimal
Constraint Satisfaction	Varies	O(n²)	Yes (constraint checking)
String Partitioning	O(n · 2ⁿ)	O(n)	Yes (validity check)

The Backtracking Template#

Every backtracking problem follows this structure:

Binary Search — Advanced Patterns

Mon, 01 Jan 0001 00:00:00 +0000

Binary Search — Advanced Patterns#

Binary search goes far beyond sorted arrays. The key insight: whenever you can define a monotonic predicate over a search space, binary search applies. This unlocks solutions to capacity problems, optimisation tasks, and rotated-array puzzles.

Pattern Summary#

Pattern	Typical Problem	Search Space	Time
Classic sorted search	Find target in array	Array indices	O(log n)
Bisect on answer	Minimum capacity to ship	Answer range [lo, hi]	O(n · log(answer range))
Rotated array	Search in rotated sorted array	Array indices	O(log n)
Minimise maximum	Split array into k subarrays	[max_element, total_sum]	O(n · log S)
2D matrix search	Search row-sorted + col-sorted	Flattened index or staircase	O(log(m·n)) or O(m+n)
First/last occurrence	Lower bound / upper bound	Array indices	O(log n)

The Binary Search Template#

Most problems use one of two forms — find the leftmost position where a condition becomes true:

Graphs

Mon, 01 Jan 0001 00:00:00 +0000

Graphs#

Graph problems appear in ~20% of technical interviews. They combine traversal patterns with problem-specific insight — knowing BFS/DFS is necessary but not sufficient. This section covers the patterns that let you recognise and solve graph problems systematically.

When You’re Looking at a Graph Problem#

Not every graph problem looks like “given a graph.” Recognise the disguises:

Problem Description	Hidden Graph
“Find if there’s a path from A to B”	BFS/DFS traversal
“Find the shortest route”	BFS (unweighted) or Dijkstra (weighted)
“Detect a cycle in dependencies”	Cycle detection (DFS)
“Order tasks given prerequisites”	Topological sort
“Group connected items”	Connected components (Union-Find or DFS)
“Can you colour/bipartite?”	BFS/DFS 2-colouring
“Minimum cost to connect all nodes”	Minimum spanning tree

Pattern 1: BFS — Shortest Path in Unweighted Graphs#

from collections import deque

def shortest_path(graph, start, target):
 queue = deque([(start, 0)])
 visited = {start}

 while queue:
 node, dist = queue.popleft()
 if node == target:
 return dist
 for neighbor in graph[node]:
 if neighbor not in visited:
 visited.add(neighbor)
 queue.append((neighbor, dist + 1))
 return -1 # not reachable

Use BFS when: shortest path in unweighted graph, level-order traversal, minimum steps/moves.

Dynamic Programming

Mon, 01 Jan 0001 00:00:00 +0000

Dynamic Programming#

Dynamic programming (DP) is an optimisation technique for problems with overlapping subproblems and optimal substructure. It avoids redundant computation by storing results of subproblems. DP appears in ~25% of medium/hard interview problems.

Recognising DP Problems#

Signal	Example
“Find the minimum/maximum”	Minimum cost to reach target
“Count the number of ways”	Number of paths, combinations
“Is it possible to…?”	Can you partition into equal subsets?
“Find the longest/shortest”	Longest increasing subsequence
Choices at each step affect future options	Buy/sell stock, house robber
Problem has recursive structure	Fibonacci, grid paths

The Two Approaches#

Top-Down (Memoisation)#

Start from the original problem, recurse, cache results:

Tries & Advanced Structures

Mon, 01 Jan 0001 00:00:00 +0000

Tries & Advanced Structures#

Specialised data structures that solve specific problem categories more efficiently than generic ones. Tries dominate prefix problems, segment trees handle range queries, and monotonic structures optimise sliding window patterns.

Trie (Prefix Tree)#

A tree where each node represents a character. Paths from root to nodes form prefixes; paths to marked nodes form complete words.

class TrieNode:
 def __init__(self):
 self.children = {}
 self.is_end = False

class Trie:
 def __init__(self):
 self.root = TrieNode()

 def insert(self, word):
 node = self.root
 for char in word:
 if char not in node.children:
 node.children[char] = TrieNode()
 node = node.children[char]
 node.is_end = True

 def search(self, word):
 node = self._find(word)
 return node is not None and node.is_end

 def starts_with(self, prefix):
 return self._find(prefix) is not None

 def _find(self, prefix):
 node = self.root
 for char in prefix:
 if char not in node.children:
 return None
 node = node.children[char]
 return node

Complexity#

Operation	Time	Space
Insert	O(m)	O(m) per word
Search	O(m)	—
Prefix check	O(m)	—

Where m = word length.