The Ultimate Guide to 16 Coding Interview Patterns Every Software Engineer Must Master

1. Two Pointers

Two Pointers is one of the most commonly used and high-impact interview patterns. Instead of repeatedly traversing an array with nested loops, this technique uses two indices (pointers) to efficiently scan or process data in a single pass.

These pointers can behave in different ways depending on the problem:

• They may move toward each other
• They may move in the same direction
• They may move at different speeds

The core strength of this pattern lies in optimization. Many brute-force solutions with O(n²) complexity can often be reduced to O(n) using Two Pointers. This makes it especially powerful in coding interviews where efficiency is a key evaluation factor.

It is widely used in problems involving sorted arrays, strings and linked lists, where relative positioning of elements plays an important role.

Where to Use

Two Pointers is typically used when:

• The array or input is sorted or can be sorted
• You need to find a pair or triplet with a target condition
• You are dealing with palindromes or symmetric checks
• You need in-place modification of an array
• You want to remove duplicates efficiently
• You are solving partitioning or rearrangement problems

Interview Clues

Look for this pattern when the problem mentions:

• Find two numbers…
• Find triplets…
• Sorted array…
• Pair with target sum…
• Check palindrome…
• In-place modification…

Common Problems

Easy

• Valid Palindrome
• Remove Duplicates from Sorted Array
• Move Zeroes

Medium

• Two Sum II (Input Array is Sorted)
• 3 Sum
• Container With Most Water
• Sort Colors

Hard

• Trapping Rain Water
• Subarray / partition optimization variations
• Advanced interval or partition-based problems

2. Sliding Window

Sliding Window is a specialized extension of the Two Pointers technique that focuses on efficiently processing contiguous segments of an array or string. Instead of recalculating results for every possible subarray or substring, we maintain a dynamic window over the data and update the result incrementally as elements enter or leave the window.

This approach significantly reduces redundant computations and often transforms brute-force O(n²) solutions into efficient O(n) solutions. Because of this, Sliding Window is one of the highest-impact patterns in coding interviews and appears frequently in array and string-based problems.

Where to Use

Sliding Window is typically used when:

• You are working with subarrays or substrings
• You need to analyze a continuous sequence
• You are asked to find the longest or shortest valid window
• You need to compute maximum or minimum values over a range
• A fixed-size window (K) is involved

Interview Clues

This pattern is often triggered by keywords such as:

• Longest substring…
• Maximum subarray…
• Minimum window…
• Contiguous sequence…
• Subarray of size K…

Common Problems

Easy

• Maximum Sum of Subarrays of Size K

Medium

• Longest Substring Without Repeating Characters
• Longest Repeating Character Replacement
• Maximum Sum of Distinct Subarrays of Size K
• Maximum Points You Can Obtain From Cards

Hard

• Minimum Window Substring
• Sliding Window Maximum

3. Intervals

Interval-based problems involve working with ranges defined by a start and end point. These problems are highly practical because they directly map to real-world scenarios such as scheduling systems, booking platforms, calendar management and resource allocation.

A common pattern in interval problems is to first sort the intervals by start time and then iterate through them to detect overlaps, merge ranges or identify gaps. Once sorted, the logic becomes significantly more manageable because relationships between intervals become linear and predictable.

Where to Use

Use Intervals when:

• You are working with time schedules or calendars
• The problem involves booking or reservation systems
• You need to manage time slots or ranges
• You are required to merge overlapping intervals
• You need to detect conflicts or overlaps
• You are analyzing availability or free time slots

Interview Clues

This pattern is commonly indicated by keywords such as:

• Meeting schedule…
• Calendar booking…
• Time slots…
• Merge overlapping intervals…
• Find free time…
• Non-overlapping ranges…

Common Problems

Easy

• Can Attend Meetings
• Meeting Rooms (I)

Medium

• Merge Intervals
• Insert Interval
• Non-overlapping Intervals
• Meeting Rooms II
• Interval List Intersections
• Minimum Number of Arrows to Burst Balloons
• Remove Covered Intervals
• Merge Sorted Intervals
• Car Pooling

Hard

• Employee Free Time
• Maximum CPU Load / Task Scheduling with Overlaps
• Range Module (Dynamic Interval Management)
• My Calendar I / II / III (Advanced Booking System)
• Minimum Interval to Include Each Query
• Skyline Problem

4. Stack

A Stack follows the Last In First Out (LIFO) principle, meaning the most recently added element is the first one to be removed or processed. Because of this behavior, stacks are extremely effective for handling nested structures, backtracking-like processes, expression parsing and order-sensitive problems. They are also heavily used in problems involving monotonic sequences, where maintaining increasing or decreasing order is important.

Many complex-looking interview problems become much simpler once you recognize that a stack can be used to track state, previous elements or hierarchical structure.

Where to Use

Use Stack when:

• You are dealing with nested or hierarchical structures
• You need to validate or process parentheses or brackets
• The problem involves expression evaluation or parsing
• You need to find next greater/smaller elements
• You are implementing undo/redo-like behavior
• You need to maintain monotonic increasing or decreasing order

Interview Clues

This pattern is often suggested by keywords such as:

• Valid parentheses…
• Nested structure…
• Previous greater element…
• Expression evaluation…
• Next greater / smaller…
• Remove / collapse adjacent elements…

Common Problems

Easy

• Valid Parentheses
• Remove Outermost Parentheses
• Baseball Game

Medium

• Daily Temperatures
• Decode String
• Min Stack
• Next Greater Element I & II
• Evaluate Reverse Polish Notation
• Remove All Adjacent Duplicates in String
• Asteroid Collision

Hard

• Largest Rectangle in Histogram
• Longest Valid Parentheses
• Basic Calculator / Calculator II / Calculator III
• Maximum Rectangle in Binary Matrix

5. Linked List

A Linked List is a linear data structure where elements (nodes) are connected using pointers, rather than being stored in contiguous memory like arrays. Each node contains a value and a reference to the next node (and sometimes the previous node in doubly linked lists). Because of this structure, linked lists excel in scenarios where frequent insertions and deletions are required, but they require careful pointer handling.

Interviewers often include linked list problems because they test a candidate’s ability to manage pointers, understand memory references and perform in-place transformations without additional space.

Where to Use

Use Linked Lists when:

• You need to perform node-level manipulation
• The problem involves frequent insertions or deletions
• You are required to detect or handle cycles in a structure
• You need to reorder or reverse nodes
• You are merging or combining multiple linked sequences
• You want to simulate dynamic data structures with flexible size

Interview Clues

This pattern is commonly indicated by keywords such as:

• Reverse linked list…
• Detect cycle…
• Find middle node…
• Merge two lists…
• Reorder nodes…
• Remove / insert node…

Common Problems

Easy

• Linked List Cycle
• Palindrome Linked List
• Reverse Linked List

Medium

• Remove Nth Node From End of List
• Reorder List
• Swap Nodes in Pairs
• Merge Two Sorted Lists
• Intersection of Two Linked Lists
• Middle of the Linked List
• Add Two Numbers

Hard

• Reverse Nodes in k-Group
• LRU Cache (Linked List + HashMap design)
• Copy List with Random Pointer

6. Binary Search

Binary Search is a fundamental algorithm that works by repeatedly dividing the search space into two halves. Instead of scanning every element, it eliminates half of the remaining possibilities in each step based on a comparison condition.

This divide-and-conquer strategy reduces the time complexity from O(n) to O(log n), making it one of the most powerful optimization techniques in coding interviews. Beyond simple searching, Binary Search is also widely used in searching on answer problems where the goal is to find the minimum or maximum feasible value.

Where to Use

Use Binary Search when:

• The data is sorted or can be logically ordered
• The problem has a monotonic condition (true/false changes in one direction)
• You need to find a minimum valid value
• You need to find a maximum feasible value
• You are searching in a search space rather than a simple array index
• The problem can be reduced to decision-making over a range

Interview Clues

This pattern is often indicated by phrases such as:

• Sorted array…
• Find minimum possible…
• Find maximum value…
• Optimize / minimize / maximize…
• Search efficiently…
• Answer lies in a range…

Common Problems

Medium

• Koko Eating Bananas
• Search in Rotated Sorted Array
• Find First and Last Position of Element in Sorted Array
• Find Peak Element
• Capacity to Ship Packages Within D Days
• Time Based Key-Value Store
• Find Minimum in Rotated Sorted Array
• Single Element in a Sorted Array

Hard

• Median of Two Sorted Arrays
• Split Array Largest Sum
• Aggressive Cows (Binary Search on Answer)
• Allocate Books Problem
• Minimize Maximum Distance to Gas Station

7. Heap (Priority Queue)

A Heap is a specialized tree-based data structure designed to efficiently access the minimum or maximum element at any given time.

It is commonly implemented using a Priority Queue, which allows elements to be inserted and removed based on priority rather than insertion order. This makes heaps extremely useful in scenarios where we need continuous access to the most important element.

Heaps are widely used in real-world systems like ranking engines, task schedulers, streaming systems and recommendation pipelines. In interviews, they frequently appear in Top-K problems and dynamic ordering scenarios.

Where to Use

Use Heap when:

• You need to find Top K elements
• You are solving Kth largest or Kth smallest problems
• The problem involves priority-based processing
• You need to repeatedly extract minimum or maximum values
• You are dealing with closest or farthest elements
• You are merging multiple sorted structures efficiently

Interview Clues

This pattern is often indicated by keywords such as:

• Top K…
• Kth largest / smallest…
• Highest priority…
• Closest elements…
• Schedule based on priority…
• Maintain running maximum/minimum…

Common Problems

Medium

• Kth Largest Element in an Array
• K Closest Points to Origin
• Find K Closest Elements
• Top K Frequent Elements
• Sort Characters By Frequency
• Last Stone Weight
• Reorganize String

Hard

• Merge K Sorted Lists
• Find Median from Data Stream
• Smallest Range Covering Elements from K Lists
• Task Scheduler (with cooling intervals)
• The Skyline Problem

8. Depth First Search (DFS)

Depth First Search (DFS) is a traversal technique where we explore one path as deeply as possible before backtracking. It follows the idea of going down a route step by step until no further progress is possible, then returning to explore alternative paths. You can think of DFS like navigating a maze: you keep moving forward along a path until you hit a dead end, then you backtrack and try another route. Because of this behavior, DFS is naturally implemented using recursion or an explicit stack.

DFS is one of the most essential techniques in trees and graphs and is widely used for exploring structure, checking connectivity and solving recursive decomposition problems.

Where to Use

Use DFS when:

• You are performing tree traversal
• You need to explore a graph or connected structure
• The problem involves finding connected components
• You need to solve grid-based islands problems
• You are doing recursive exploration or backtracking
• You need to explore all possible paths or configurations

Interview Clues

This pattern is often indicated by keywords such as:

• Tree traversal…
• Connected components…
• Number of islands…
• Path finding…
• Explore all possibilities…
• Flood fill…

Common Problems

Easy

• Maximum Depth of Binary Tree
• Path Sum
• Flood Fill
• Binary Tree Inorder / Preorder / Postorder Traversal
• Diameter of Binary Tree (basic form)

Medium

• Number of Islands
• Validate Binary Search Tree
• Pacific Atlantic Water Flow
• Surrounded Regions
• Clone Graph
• Path Sum II
• Course Schedule (DFS cycle detection)

Hard

• Word Search II
• Alien Dictionary
• Reconstruct Itinerary
• N-Queens
• Expression Add Operators

9. Breadth First Search (BFS)

Breadth First Search (BFS) is a traversal technique where nodes are explored level by level. Unlike DFS, which goes deep into one path first, BFS explores all immediate neighbors before moving to the next level. This behavior makes BFS especially powerful for finding the shortest path in unweighted graphs, as it guarantees that the first time you reach a node, it is through the shortest possible route.

BFS is typically implemented using a queue, which helps maintain the order of exploration across levels.

Where to Use

Use BFS when:

• You need to find the shortest path (unweighted graphs)
• The problem involves minimum number of moves or steps
• You are performing level order traversal in trees
• You need to find the closest or nearest node
• You are exploring a multi-source expansion (spread/propagation problems)

Interview Clues

This pattern is commonly indicated by keywords such as:

• Shortest path…
• Minimum steps…
• Level order traversal…
• Minimum moves…
• Reach target in fewest moves…
• Spread/rotting/expansion…

Common Problems

Easy

• Binary Tree Level Order Traversal
• Average of Levels in Binary Tree
• Minimum Depth of Binary Tree

Medium

• Binary Tree Zigzag Level Order Traversal
• Rotting Oranges
• 01 Matrix
• Word Ladder
• Populating Next Right Pointers in Each Node
• Shortest Path in Binary Matrix

Hard

• Minimum Knight Moves
• Bus Routes
• Word Ladder II
• Sliding Puzzle
• Shortest Path in a Grid with Obstacles Elimination

10. Backtracking

Backtracking is a problem-solving technique that systematically explores all possible solutions and abandons paths that cannot lead to a valid result.

It works like a decision tree where each node represents a decision and each branch represents a possible choice. As we move deeper into the tree, we build a partial solution; if it becomes invalid or complete, we either backtrack or record the result.

This pattern is especially powerful for problems involving combinatorics, permutations, subsets and constraint-based search, where brute force exploration is required but must be controlled efficiently.

Where to Use

Use Backtracking when:

• You need to generate all combinations
• You need to generate subsets or power sets
• You are required to find permutations or arrangements
• The problem involves searching all possible paths
• You are solving constraint satisfaction problems
• You need to explore all valid configurations

Interview Clues

This pattern is often indicated by keywords such as:

• Generate all…
• Find all combinations…
• All possible ways…
• Explore all paths…
• Return all valid solutions…
• Combinatorial search…

Common Problems

Medium

• Subsets
• Subsets II
• Permutations
• Combination Sum
• Combination Sum II
• Generate Parentheses
• Letter Combinations of a Phone Number
• Word Search
• Palindrome Partitioning

Hard

• N-Queens
• N-Queens II
• Sudoku Solver
• Word Search II
• Expression Add Operators
• Restore IP Addresses

11. Graphs

Graphs are one of the most important data structures in coding interviews because they are used to model relationships between entities.

Unlike arrays or trees, graphs are more general in nature and can represent complex real-world systems such as social networks, road maps, dependency chains, recommendation systems and communication networks.

A graph consists of nodes (vertices) and edges, where edges represent relationships or connections between nodes. Depending on the problem, these edges can be directed, undirected, weighted or unweighted.

Graph problems primarily test your understanding of traversal techniques (DFS and BFS), connectivity, cycle detection, shortest paths and topological ordering.

Where to Use

Use Graphs when:

• There are dependencies between elements
• You are dealing with networks or connected systems
• The problem involves relationships or connections
• You need to check connectivity or reachability
• You are solving ordering or dependency resolution problems
• You are working with paths, cycles or shortest routes

Interview Clues

This pattern is often indicated by keywords such as:

• Dependency…
• Prerequisites…
• Course scheduling…
• Connected components…
• Network traversal…
• Path between nodes…

Common Problems

Medium

• Course Schedule
• Course Schedule II
• Number of Provinces
• Clone Graph
• Pacific Atlantic Water Flow
• Graph Valid Tree
• Redundant Connection
• Cheapest Flights Within K Stops
• All Paths From Source to Target

Hard

• Word Ladder II
• Alien Dictionary
• Critical Connections in a Network (Bridges)
• Minimum Cost to Reach Destination
• Shortest Path in a Weighted Graph (Dijkstra-based problems)
• Reconstruct Itinerary

12. Dynamic Programming (DP)

Dynamic Programming is a powerful problem-solving technique used to solve complex problems by breaking them into smaller, overlapping subproblems.

Instead of recomputing the same results multiple times, DP stores intermediate results and reuses them whenever needed. This optimization dramatically improves efficiency in problems that would otherwise have exponential time complexity.

DP is often considered one of the most challenging topics in coding interviews because the hardest part is not implementation, but identifying the state definition and recurrence relation that connects subproblems.

Where to Use

Use Dynamic Programming when:

• You need to find a maximum or minimum value
• The problem involves counting number of ways
• You are solving optimization problems
• You need to make a sequence of decisions
• The problem has overlapping subproblems
• A greedy approach does not fully work

Interview Clues

This pattern is often indicated by keywords such as:

• Maximum profit…
• Minimum cost…
• Number of ways…
• Count all possible…
• Optimize…
• Best possible outcome…

Common Problems

Easy

• Counting Bits
• Climbing Stairs
• Min Cost Climbing Stairs

Medium

• Decode Ways
• Unique Paths
• Longest Increasing Subsequence
• Word Break
• Coin Change
• House Robber
• Maximum Product Subarray
• Partition Equal Subset Sum
• Maximum Profit in Job Scheduling

Hard

• Edit Distance
• Regular Expression Matching
• Burst Balloons
• Palindrome Partitioning II
• Distinct Subsequences
• Russian Doll Envelopes

13. Greedy Algorithms

Greedy Algorithms are a problem-solving technique where we make the best possible choice at each step, with the hope that these local optimal decisions will lead to a globally optimal solution.

Unlike Dynamic Programming, which explores multiple possibilities, Greedy approaches commit to a decision immediately without revisiting it. This makes them simpler, faster and often more efficient—but they only work when the problem has the right structure.

Greedy solutions are typically elegant and intuitive once the correct strategy is identified, but the main challenge is proving that a local choice leads to an optimal global outcome.

Where to Use

Use Greedy when:

• You need to solve an optimization problem
• A local decision influences the final result
• You are dealing with resource allocation
• The problem involves scheduling or interval selection
• You can sort or prioritize choices
• Future decisions do not depend heavily on past choices

Interview Clues

This pattern is often indicated by keywords such as:

• Maximum / minimum…
• Optimize…
• Best possible…
• Schedule tasks…
• Choose most efficient option…
• Minimize cost / maximize profit…

Common Problems

Easy

• Best Time to Buy and Sell Stock
• Assign Cookies
• Lemonade Change

Medium

• Gas Station
• Jump Game
• Partition Labels
• Task Scheduler
• Non-overlapping Intervals (Greedy variant)
• Reorganize String
• Queue Reconstruction by Height

Hard

• Candy
• Minimum Number of Refueling Stops
• Merge Triplets to Form Target Triplet
• IPO (Maximize Capital)
• Meeting Rooms II (Greedy + heap hybrid)

14. Trie

A Trie is a specialized tree data structure used for efficiently storing and retrieving strings, especially when operations involve prefix matching.

Each node in a Trie represents a single character and paths from the root represent complete words or prefixes. This structure enables very fast lookup operations compared to linear search, particularly when dealing with large dictionaries of words.

Tries are widely used in systems such as search engines, autocomplete features, spell checkers and dictionary-based applications where prefix-based querying is a core requirement.

Where to Use

Use Trie when:

• You need prefix-based searching
• You are implementing autocomplete or suggestion systems
• The problem involves dictionary or word lookup
• You need to efficiently check whether a word or prefix exists
• You are working with a large collection of strings
• Fast insert and search operations on strings are required

Interview Clues

This pattern is often indicated by keywords such as:

• Prefix search…
• Starts with…
• Autocomplete…
• Dictionary of words…
• Search suggestions…
• Efficient word lookup…

Common Problems

Medium

• Implement Trie (Prefix Tree)
• Design Add and Search Words Data Structure
• Replace Words
• Map Sum Pairs
• Search Suggestions System
• Word Search II (Trie + DFS combination)

Hard

• Word Search II (optimized Trie + backtracking)
• Palindrome Pairs
• Design Search Autocomplete System
• Stream of Characters
• Word Squares

15. Prefix Sum

Prefix Sum is a technique used to precompute cumulative sums (or cumulative values) so that range-based queries can be answered efficiently.

Instead of recalculating values for every query or subarray, we store intermediate results and reuse them. This significantly reduces repeated computation and improves performance in range query problems.

With prefix sums, many problems that would normally require O(n) per query can often be reduced to O(1) after preprocessing.

Where to Use

Use Prefix Sum when:

• You need to answer range sum queries
• The problem involves subarray calculations
• You are working with cumulative totals
• You need frequency or count tracking over ranges
• Repeated sum computation over overlapping intervals is required

Interview Clues

This pattern is often indicated by keywords such as:

• Range sum…
• Subarray sum…
• Sum between indices…
• Count occurrences in range…
• Continuous sum…
• Query over subarray…

Common Problems

Medium

• Subarray Sum Equals K
• Continuous Subarray Sum
• Find Pivot Index
• Range Sum Query – Immutable
• Product of Array Except Self (prefix + suffix idea)
• Count Number of Nice Subarrays
• Maximum Size Subarray Sum Equals K
• Count Vowel Strings in Ranges

16. Matrix Problems

Matrix problems involve working with two-dimensional grids where elements are arranged in rows and columns. These problems are very common in coding interviews because they often combine multiple core concepts such as traversal, simulation, BFS, DFS and graph modeling.

A matrix can also be interpreted as an implicit graph, where each cell represents a node and its neighbors represent edges. Because of this, many graph techniques are directly applicable to matrix-based problems.

Mastering matrix problems significantly improves your ability to handle grid-based traversal, pathfinding and state simulation problems.

Where to Use

Use Matrix when:

• You need to perform grid traversal
• The problem involves image or pixel manipulation
• You are solving simulation-based problems
• You need path finding in a grid or maze
• You are working with board games or movement rules
• The problem can be modeled as a graph on a grid

Interview Clues

This pattern is often indicated by keywords such as:

• Grid…
• Matrix…
• Row and column…
• Island…
• Maze…
• Path in a grid…

Common Problems

Medium

• Spiral Matrix
• Rotate Image
• Set Matrix Zeroes
• Number of Islands (grid-based DFS/BFS overlap)
• Word Search (matrix + backtracking)
• Flood Fill
• Search a 2D Matrix II

Hard

• Trapping Rain Water II
• Sudoku Solver
• N-Queens (grid backtracking variant)
• The Maze III
• Shortest Path in Binary Matrix

Final Thoughts

If you are preparing for coding interviews, the most effective approach is to master these 16 core problem-solving patterns rather than attempting to solve hundreds of random problems without structure. Strong interview performance is less about memorizing solutions and more about developing pattern recognition skills. Once you can identify the underlying pattern in a new problem, the solution becomes significantly easier to derive.

A solid understanding of key patterns such as Two Pointers, Sliding Window, DFS, BFS, Binary Search, Dynamic Programming and Graphs will already cover a large portion of questions asked by major technology companies.

Instead of scattered practice, a structured approach works best. A practical study order is:

Two Pointers → Sliding Window → Stack → Linked List → Binary Search → Intervals → Heap → DFS → BFS → Backtracking → Graphs → Greedy → Prefix Sum → Dynamic Programming → Trie → Matrix

By following this progression, you gradually build from foundational techniques to more advanced concepts. Ultimately, mastering these patterns allows you to see structure in problems quickly, rather than treating every question as something entirely new.