Most DSA interview questions are not new. They are variations on a small set of recurring patterns, and once you can recognise the pattern behind a question, the solution follows almost mechanically. Freshers who memorise fifty specific problems stall on the fifty-first. Freshers who learn the seven or eight underlying patterns can attack a problem they have never seen.
Seven patterns carry most of the load in placement and product-company coding rounds: two pointers, sliding window, hashing, recursion and backtracking, trees, graphs, and dynamic programming. Learn to spot them, and the coding round stops being a memory test and becomes pattern recognition.
Two pointers: shrink the search from both ends
The two-pointer pattern uses two indices moving through a sorted array, usually one from each end, to avoid checking every pair.
Take the classic: given a sorted array, find two numbers that sum to a target. The brute force checks every pair in O(n squared). With two pointers, start one at the first element and one at the last, then compare their sum against the target. If the sum is too small, move the lower pointer forward to a bigger value; if it is too big, move the upper pointer back to a smaller one. Each move eliminates a whole row of pairs at once, so a single pass settles it.
Complexity: O(n) time, O(1) extra space, on an already sorted array.
How it is tested: pair-sum, three-sum, container-with-most-water, removing duplicates in place. The tell is a sorted array and a question about pairs or ranges.
Sliding window: a moving range over a sequence
The sliding window pattern maintains a contiguous range and slides it across an array or string, expanding and contracting instead of recomputing from scratch.
Example: find the longest substring without repeating characters. Keep a window and a set of characters inside it. Expand the right edge, adding characters; when you hit a repeat, shrink from the left until the repeat is gone. Track the largest window size seen.
Complexity: O(n), because each character enters and leaves the window at most once.
How it is tested: longest or shortest substring under a constraint, maximum sum of k consecutive elements, anagram detection.
Hashing: trade space for constant-time lookup
Hashing stores elements in a hash map or set so membership and counting become O(1) on average. It is the pattern that converts an O(n squared) nested scan into a single pass.
Example: does an array contain a duplicate? Walk once, inserting each element into a set; if an element is already present, you have your answer. Or, for two-sum on an unsorted array, store each number's complement in a map and check for it as you go.
Complexity: O(n) time, O(n) space, average case. Worst-case lookups degrade with poor hash distribution.
How it is tested: frequency counts, first-non-repeating character, subarray-sum-equals-k, grouping anagrams. Whenever a question asks "have I seen this before", think hashing.
Recursion and backtracking: build, test, undo
Recursion solves a problem by reducing it to smaller instances of itself. Backtracking is recursion that builds a partial solution, tests it, and undoes the last step when it leads nowhere.
Example: generate all subsets of a set. At each element, branch twice, one path includes it, one excludes it, and recurse on the rest. The base case is an empty remaining set, where you record the built subset. The undo is what makes it backtracking: after the include-branch returns, you remove that element from the partial answer before taking the exclude-branch, so the two paths never contaminate each other.
Complexity: subsets and permutations are exponential by nature (there are 2 to the n subsets), so the cost is in the output size. Backtracking's value is pruning branches early so you never explore dead ends fully.
How it is tested: permutations, combinations, N-queens, Sudoku, word search on a grid. The signal is "find all" or "is there a valid arrangement".
Trees: recursion with two branches
Binary-tree questions are recursion in disguise. Most reduce to "solve the left subtree, solve the right subtree, combine".
Example: the height of a binary tree is one plus the maximum of the left and right subtree heights, with an empty tree having height zero. Traversals (inorder, preorder, postorder) follow the same recursive shape, and level-order traversal uses a queue instead.
Complexity: O(n) to visit every node once; the recursion stack costs O(h), the tree's height.
How it is tested: traversals, height and diameter, lowest common ancestor, checking if a tree is balanced or a valid binary search tree.
Graphs: traversal is the foundation
Graph questions almost always start from a traversal, breadth-first search (BFS) or depth-first search (DFS), and build from there.
Example: count the connected components in an undirected graph. Run DFS or BFS from each unvisited node; each fresh start is one new component. BFS also gives the shortest path in an unweighted graph, because it explores level by level. Both traversals are traced node by node, along with Dijkstra and the weighted shortest-path algorithms built on them, in our graph algorithms: BFS, DFS and shortest paths walkthrough.
Complexity: O(V plus E) for both BFS and DFS, where V is vertices and E is edges, using an adjacency list.
How it is tested: number of islands, cycle detection, shortest path in a grid, topological sort of dependencies. If the data is a network or a grid of connections, it is a graph problem.
Dynamic programming: remember, do not recompute
Dynamic programming (DP) solves problems with overlapping subproblems by solving each subproblem once and storing the result, instead of recomputing it exponentially many times.
Example: the n-th Fibonacci number. Naive recursion recomputes the same values exponentially. Store each computed value in an array (or two rolling variables) and the cost collapses to linear. The same "define a state, write a recurrence, fill a table" method solves knapsack, longest common subsequence, and coin change; the 0/1 knapsack table is filled in cell by cell in our dynamic programming explained walkthrough.
Complexity: typically O(number of states times work per state). Fibonacci is O(n); the 0/1 knapsack is O(n times capacity).
How it is tested: min or max cost, count-the-ways, can-you-partition questions. The tell is that a greedy choice fails and the same subproblem recurs.
How these patterns show up in placement rounds
Placement coding rounds and product-company interviews draw on exactly these patterns, usually one or two per problem, occasionally combined (a sliding window that uses a hash map, a graph that needs DP on top). KnowledgeGate's question bank carries over 1,400 data-structures questions and more than 1,100 algorithm questions, so every pattern here has enough practice behind it to drill until recognition is automatic.
The way to use them is to solve by pattern, not by problem. When you read a new question, ask which pattern it fits before you write a line: sorted array and pairs points to two pointers; "have I seen this" points to hashing; "find all arrangements" points to backtracking; overlapping subproblems point to DP.
Your next step
If you want these patterns taught in order with interview-focused problems and solutions, our DSA using Java course is built for product-based placement coding rounds and technical interviews. If your programming fundamentals need firming up first, the Coding for Placements course covers C, C++, Java and Python from the basics.
The full placement preparation category collects the rest, from the aptitude rounds to the company-wise interview guides.
Learn the pattern behind the question, practise until recognition is instant, and the coding round becomes marks you count on rather than a topic you fear.
