The Ultimate Guide to 16 Coding Interview Patterns Every Software Engineer Must Master
If you ask experienced software engineers how they solve coding interview problems so quickly and consistently, most of them will give a surprisingly simple answer:
They do not memorize hundreds of individual solutions. Instead, they learn to recognize patterns.
One of the biggest misconceptions among interview candidates is that success comes from solving thousands of random problems and remembering every solution. In reality, top performers focus on understanding a relatively small set of problem-solving patterns that repeatedly appear across coding interviews. Once you understand these patterns, you can approach unfamiliar problems with confidence and identify the underlying technique required to solve them.
Pattern recognition is often far more valuable than solution memorization. Interviewers are not looking for candidates who can recall a specific answer from memory. they are looking for engineers who can analyze a problem, identify the appropriate approach and apply it effectively. This is why many interview-preparation platforms and educational resources organize problems into recurring categories such as Two Pointers, Sliding Window, Fast and Slow Pointers, Depth-First Search (DFS), Breadth-First Search (BFS), Binary Search, Dynamic Programming, Backtracking and several others.
The good news is that a large percentage of coding interview questions asked by top technology companies can be solved using a core set of algorithmic patterns. By mastering these patterns, you can dramatically improve your problem-solving speed, reduce interview anxiety and build a structured approach to tackling new questions.
In this guide, we will explore the 16 most important coding interview patterns that every candidate should know. For each pattern, we will discuss what it is, when to use it, the types of problems it solves and a curated list of practice questions to help you strengthen your understanding and prepare effectively for technical interviews.
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
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
islandsproblems - 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.
![\"Amazon](\"https://m.media-amazon.com/images/G/31/img17/AmazonPay/Aditya_Vangala/Main-Page_PC_01_KSD.jpg\")
\n