23 DSA Patterns That Cover 90% of Coding Interview Questions

RHODY FF — Thu, 01 Jan 2026 17:54:35 +0000

The Problem with LeetCode Grinding

Let me guess your DSA preparation strategy:

Open LeetCode
Sort by "Most Liked"
Solve random problems
Repeat until placement season

The result? 500+ problems solved, yet freezing in interviews because you can't recognize the pattern.

I built W Code to fix this. Today, I'm sharing the pattern framework that has helped students crack TCS, Infosys, and FAANG interviews.

The 23 Core DSA Patterns

Array Patterns

Two Pointers

Example: Two Sum (Sorted Array)

def two_sum(arr, target):
left, right = 0, len(arr) - 1
while left < right:
curr_sum = arr[left] + arr[right]
if curr_sum == target:
return [left, right]
elif curr_sum < target:
left += 1
else:
right -= 1
return [-1, -1]

Use when: Finding pairs, removing duplicates, container with most water

Sliding Window

Example: Maximum Sum Subarray of Size K

def max_sum_subarray(arr, k):
window_sum = sum(arr[:k])
max_sum = window_sum
for i in range(k, len(arr)):
window_sum += arr[i] - arr[i - k]
max_sum = max(max_sum, window_sum)
return max_sum

Use when: Subarrays of fixed/variable size, longest substring problems

Prefix Sum
Use when: Range sum queries, subarray sum equals K
Kadane's Algorithm
Use when: Maximum subarray sum

🔗 Linked List Patterns

Fast & Slow Pointers

Example: Detect Cycle

def has_cycle(head):
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
if slow == fast:
return True
return False

Use when: Cycle detection, middle of linked list, nth from end

Reverse Linked List Use when: Palindrome check, reverse in groups

🌲 Tree Patterns

BFS (Level Order)

from collections import deque

def level_order(root):
if not root:
return []
result = []
queue = deque([root])
while queue:
level = []
for _ in range(len(queue)):
node = queue.popleft()
level.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
result.append(level)
return result

Use when: Level-by-level traversal, zigzag, right view

8.DFS (Recursive)
Use when: Path sum, validate BST, diameter

9.Binary Search on BST
Use when: Search, insert, delete, kth smallest

GRAPH PATTERNS

10.BFS on Graph
Use when: Shortest path (unweighted), connected components

11.DFS on Graph
Use when: Cycle detection, connected components

12.Topological Sort

Python logic (Kahn’s Algorithm):

from collections import deque, defaultdict

def topological_sort(n, edges):
graph = defaultdict(list)
in_degree = [0] * n

for u, v in edges:
    graph[u].append(v)
    in_degree[v] += 1

queue = deque([i for i in range(n) if in_degree[i] == 0])
result = []

while queue:
    node = queue.popleft()
    result.append(node)
    for neighbor in graph[node]:
        in_degree[neighbor] -= 1
        if in_degree[neighbor] == 0:
            queue.append(neighbor)

return result if len(result) == n else []

Use when: Course schedule, task ordering, dependency resolution

13.Union-Find (DSU)
Use when: Connected components, cycle detection in undirected graph

14.Dijkstra’s Algorithm
Use when: Shortest path (weighted)

DYNAMIC PROGRAMMING PATTERNS

15.1D DP

Example: Climbing Stairs

def climb_stairs(n):
if n <= 2:
return n
dp = [0] * (n + 1)
dp[1], dp[2] = 1, 2
for i in range(3, n + 1):
dp[i] = dp[i-1] + dp[i-2]
return dp[n]

Use when: House robber, fibonacci variants, coin change (minimum)

16.2D DP
Use when: Grid paths, longest common subsequence, edit distance

17.0/1 Knapsack
Use when: Subset sum, partition equal sum, target sum

18.Unbounded Knapsack
Use when: Coin change (number of ways), rod cutting

19.LCS / LIS Patterns
Use when: Longest increasing subsequence, longest common substring

OTHER ESSENTIAL PATTERNS

Binary Search
Use when: Search in O(log n), search in rotated array

Backtracking

Example: Permutations

def permute(nums):
result = []
def backtrack(path, remaining):
if not remaining:
result.append(path[:])
return
for i, num in enumerate(remaining):
path.append(num)
backtrack(path, remaining[:i] + remaining[i+1:])
path.pop()
backtrack([], nums)
return result

Use when: Permutations, combinations, N-Queens, Sudoku

Monotonic Stack
Use when: Next greater element, largest rectangle in histogram

Trie (Prefix Tree)
Use when: Autocomplete, word search, prefix matching

PATTERN RECOGNITION CHEAT SHEET

If the problem says… → Think about…

Subarray of size K → Sliding Window
Pairs that sum to → Two Pointers
Detect cycle → Fast & Slow Pointers
Level by level → BFS
All paths → DFS / Backtracking
Order of completion → Topological Sort
Maximum / Minimum → Dynamic Programming
Next greater / smaller → Monotonic Stack
Prefix matching → Trie

START PRACTICING PATTERN-BASED

I’ve organized 223+ problems by these patterns at W Code:
WCode

• Free forever (200+ problems)
• TCS / Infosys / FAANG tracks
• Interactive visualizers
• AI resume analyzer

Pattern-based DSA for Indian placements.

DEV Community: RHODY FF

23 DSA Patterns That Cover 90% of Coding Interview Questions

Example: Two Sum (Sorted Array)

Example: Maximum Sum Subarray of Size K

Example: Detect Cycle