Part II — Algorithm Mastery

You’ve walked into the interview room. The whiteboard is blank. The interviewer slides a problem across the table — or shares a CoderPad link — and says, “Take your time.” Your pulse ticks up. You have 35 to 45 minutes to demonstrate not only that you can write correct code, but that you think like an engineer who builds production systems.

This section arms you with a repeatable methodology for exactly that moment. The chapters ahead dissect specific problems across ten core algorithm families. Before diving into those problems, you need a battle-tested framework and a working knowledge of the patterns that recur across hundreds of interview questions.

What Interviewers Actually Evaluate

A common misconception: the interview is a test of whether you produce the optimal solution. It is not. Interviewers assess a broader signal:

• Communication clarity — Can you explain your reasoning out loud as you work? Do you ask clarifying questions before jumping to code?
• Problem decomposition — Do you break the problem into smaller sub-problems? Can you identify the core challenge buried inside the problem statement?
• Pattern recognition — When you see an array problem asking for a contiguous subarray, do you reach for the Sliding Window pattern? When the problem involves shortest path, do you reach for BFS?
• Trade-off awareness — Can you articulate why O(n) space is acceptable here but not there? Do you discuss time vs. space trade-offs without prompting?
• Code quality — Is your code readable, well-structured, and free of off-by-one errors? Do you name variables meaningfully?
• Testing instinct — After writing code, do you walk through edge cases? Do you catch bugs before the interviewer points them out?

Producing the optimal solution earns bonus points. Demonstrating the six qualities above earns the hire decision.

The Five-Step Problem-Solving Framework

Every problem in this book follows the same five-step framework. Internalize these steps until they become reflexive.

Step 1 — Understand & Clarify

Read the problem statement twice. Then ask questions:

• What are the input constraints? (Array size up to 10⁵? Values can be negative?)
• Are inputs sorted? Can there be duplicates?
• What should I return for empty input?
• Is there a required time or space complexity?

Restating the problem in your own words confirms you understood it. Interviewers reward this step because it mirrors how senior engineers approach ambiguous requirements.

Step 2 — Identify Patterns

Match the problem to one or more known algorithm patterns (see the catalog below). Ask yourself:

• Does this involve a linear scan with some state? → Two Pointers or Sliding Window
• Does this involve searching in sorted data? → Binary Search
• Does this involve a graph or tree traversal? → BFS or DFS
• Does this involve making choices that depend on prior choices? → Dynamic Programming
• Does this involve generating all valid combinations? → Backtracking

Pattern recognition is the single highest-leverage skill you can develop. Ninety percent of interview problems map to fewer than ten patterns.

Step 3 — Design the Approach

Sketch your approach before writing code. Use examples. Trace through the algorithm by hand on the provided test case. Confirm the approach handles edge cases.

State your time and space complexity upfront. If the approach is brute force, say so — then explain how you plan to optimize.

Step 4 — Implement

Write clean, modular code. Use descriptive variable names. Extract helper methods when a block of logic distracts from the main flow.

In a 45-minute interview, implementation should take 15 to 20 minutes. If you spend 25 minutes coding, you skipped Steps 1–3 too quickly.

Step 5 — Test & Optimize

Walk through your code with the provided example. Then test with edge cases: empty input, single element, maximum size, all duplicates.

If time remains, discuss potential optimizations. Can you reduce space usage? Can you eliminate a pass? This is where you demonstrate depth.

The Pattern Catalog

The ten algorithm families below cover the vast majority of coding interview problems. Each family gets a dedicated chapter in this section.

Two Pointers

Use two indices moving through a data structure — often one from each end, or one fast and one slow. Ideal for sorted arrays, palindrome checks, and partition problems.

Sliding Window

Maintain a window over a contiguous subarray or substring. Expand the window to explore, contract it to maintain a constraint. Applies to maximum sum subarray, longest substring without repeats, and minimum window substring problems.

Binary Search

Divide the search space in half at each step. Applies beyond sorted arrays: use it whenever you can define a monotonic predicate over a search space. Powerful for “minimize the maximum” or “maximize the minimum” problems.

BFS and DFS

Breadth-First Search explores level by level — use it for shortest path in unweighted graphs. Depth-First Search explores as deep as possible first — use it for connected components, topological sort, and cycle detection.

Dynamic Programming

Break the problem into overlapping sub-problems with optimal substructure. Define a recurrence relation, then compute bottom-up (tabulation) or top-down (memoization). Handles knapsack, longest subsequence, and edit distance families.

Backtracking

Systematically explore all candidates and prune branches that violate constraints. Use for permutations, combinations, N-Queens, and Sudoku-style problems. The key insight: undo your choice before exploring the next branch.

Monotonic Stack and Queue

Maintain a stack or deque where elements are in strictly increasing or decreasing order. Use for “next greater element,” trapping rain water, and sliding window maximum problems.

Divide and Conquer

Split the problem into independent sub-problems, solve each recursively, and merge results. Merge Sort and Quick Sort are the canonical examples. Also applies to closest pair of points and median-finding.

Greedy

Make the locally optimal choice at each step, hoping it leads to a global optimum. Valid only when the problem has the greedy choice property. Applies to interval scheduling, Huffman coding, and minimum spanning tree.

Union-Find (Disjoint Set)

Track connected components efficiently with path compression and union by rank. Use for dynamic connectivity, Kruskal’s algorithm, and “number of islands” variants.

Big-O Complexity Cheat Sheet

Complexity	Name	Example Operations
O(1)	Constant	HashMap lookup, array index access
O(log n)	Logarithmic	Binary search, balanced BST operations
O(n)	Linear	Single pass through array, linear search
O(n log n)	Linearithmic	Merge sort, heap sort, efficient sorting
O(n²)	Quadratic	Nested loops, brute-force pair comparisons
O(2ⁿ)	Exponential	Recursive subsets, brute-force backtracking
O(n!)	Factorial	Generating all permutations

Rules of thumb for interviews:

• If n ≤ 20, O(2ⁿ) or O(n!) approaches are acceptable.
• If n ≤ 1,000, O(n²) is fine.
• If n ≤ 10⁵, you need O(n log n) or better.
• If n ≤ 10⁹, you need O(log n) or O(1).

These boundaries help you validate whether your approach can pass time limits before you start coding.

Java 25 Features for Interviews

Java 25 introduces language features that make interview code cleaner and more expressive. Knowing these signals to your interviewer that you stay current.

Records

Use records for lightweight data carriers — graph nodes, coordinate pairs, or return types that bundle multiple values. A record Point(int x, int y) {} replaces a full class with constructor, equals, hashCode, and toString.

Pattern Matching

Pattern matching with switch expressions and instanceof eliminates verbose casting. When processing heterogeneous data structures or tree nodes, pattern matching produces concise, readable code.

Stream Gatherers

Stream Gatherers extend the Streams API with custom intermediate operations. Where previous Java versions forced you to collect, transform, and re-stream, Gatherers let you define windowing, folding, and scanning operations inline.

Sequenced Collections

SequencedCollection, SequencedSet, and SequencedMap provide getFirst(), getLast(), and reversed() methods across List, Deque, SortedSet, and LinkedHashMap. These eliminate the awkward list.get(list.size() - 1) pattern and make code intent clearer.

What Lies Ahead

The ten chapters that follow each tackle a specific algorithm family through the lens of real interview problems:

1. Trapping Rain Water — Two Pointers, Dynamic Programming, Monotonic Stack
2. Median of Two Sorted Arrays — Binary Search on partitions
3. Sliding Window Maximum — Monotonic Deque
4. Word Ladder — BFS on implicit graphs
5. Longest Increasing Subsequence — Dynamic Programming with binary search optimization
6. N-Queens — Backtracking with constraint propagation
7. Merge K Sorted Lists — Divide and Conquer, Heap
8. Course Schedule — Topological Sort via DFS and BFS
9. Minimum Spanning Tree — Greedy with Union-Find
10. Serialize and Deserialize Binary Tree — Tree traversal and reconstruction

Each chapter follows the five-step framework. Each chapter presents multiple approaches — from brute force to optimal — so you see how the solution evolves. Each chapter ends with interviewer tips and common follow-up questions.

Read them in order, or jump to the patterns you need to strengthen. Either way, practice with pen and paper before running code. The goal is to build intuition, not memorize solutions.

Your algorithm mastery starts now.