Recursion interview questions

Implement a function that returns whether two binary trees have identical structure and node values.

Implement a function that returns the maximum depth from root to leaf in a binary tree.

Implement a function that mirrors a binary tree by swapping the left and right children of every node.

Implement a function that counts the distinct ways to climb to the top of a staircase taking one or two steps.

Maximize the value packed into a weight-limited knapsack when each item can be taken at most once — the classic 0/1 dynamic-programming table.

Tokenize and evaluate a math expression string with operator precedence, parentheses, and unary minus.

Implement a function that returns the kth smallest value in a binary search tree.

Implement a function that finds the lowest common ancestor of two nodes in a binary search tree.

Implement a function that reconstructs a binary tree given its preorder and inorder traversal sequences.

Implement a function that determines whether one binary tree appears as a subtree of another.

Implement a function that returns a new object with every key converted to camelCase, recursing into nested objects.

Implement a function that returns every unique combination of reusable candidates that sums to a target.

Implement a function that returns a deep copy of an object with all falsy values stripped from nested structures.

Implement a function that counts the number of distinct islands of connected cells in a 2D binary grid.

Implement a function that recursively clones a JSON-serializable value without sharing references.

Recursively freeze an object and every nested object and array, making the whole structure deeply immutable.

Implement a function that walks an arbitrarily nested structure and applies a transform to every leaf value.

Implement a function that recursively merges two objects, combining nested properties rather than overwriting them.

Implement a function that returns a copy of a value with the given keys stripped from every nested object.

Build a DI container that resolves a service dependency graph, caches singletons, and detects circular dependencies.

Implement depth-first traversal of a directed graph, exploring each branch fully before backtracking.

Implement a function that counts the number of unique paths a robot can take from the top-left to bottom-right of an m by n grid.

Compute the minimum number of insertions, deletions, and replacements to turn one string into another — the Levenshtein distance via a 2D dynamic-programming table.

Raise a base to an integer exponent in logarithmic time using exponentiation by squaring, handling negative exponents.

Build a file explorer that renders a nested folder hierarchy and lets you expand and collapse directories.

Implement a function that recursively flattens a nested array into a single-level array.

Compute the greatest common divisor with Euclid's algorithm and the least common multiple, for two numbers or a whole list.

Generate every well-formed combination of n pairs of parentheses by backtracking — add an open bracket while any remain, and a close bracket only while it stays balanced.

Implement a function that serializes a tree-shaped object into a pretty-printed HTML string with indentation.

Implement a function that recursively compares two DOM trees and returns whether they are structurally equal.

Implement a function that converts a JavaScript value into its JSON string representation.

Implement merge sort recursively by splitting the array and merging the sorted halves back together.

Build a threaded comments tree where each comment can be replied to and collapsed recursively.

Split a string every possible way so that each piece is a palindrome — backtrack over cut positions, extending a piece only while it reads the same both ways.

Generate every permutation and every subset of an array with the same backtracking template — choose, recurse, and undo.

List every letter string a phone number could spell, mapping each digit to its keypad letters and backtracking through the choices.

Implement quick sort recursively, partitioning around a pivot and sorting each side independently.

Implement a function that flattens a nested object into a single-level object using dot-delimited keys.

Implement a function that rebuilds a nested object from a flat map of dot-delimited keys.

Build a binary search tree with insert, search, and delete operations preserving the BST invariant.

Implement a function that returns the maximum sum of node values along any path in a binary tree.

Implement a deep clone that copies nested values and correctly handles circular references using a visited map.

Implement a function that determines whether two values are structurally equal across nested objects and arrays.

Implement JSON.parse — a recursive-descent parser that turns a JSON string into the corresponding JavaScript value.

Implement JSON.stringify with full spec support including replacer, indentation, and circular reference detection.

Build a collapsible tree that lazily loads a node's children the first time it is expanded.

Build Minesweeper with flood-fill reveal, flagging, and win/lose detection.

Place N queens on an N×N board so none attack another — a classic backtracking search that places one queen per row and prunes column and diagonal conflicts.

Build a nested checkbox tree where parent state reflects its children and toggling a parent cascades down.

Extend a tiny schema validator to handle nested object and array shapes plus optional fields.

Implement structuredClone — deep-clone a value including Map, Set, Date, RegExp, typed arrays, and circular references.

Fill a 9×9 Sudoku grid by backtracking — try each digit in the next empty cell, checking its row, column, and 3×3 box, and undo on a dead end.

Build serialize and deserialize that preserve referential identity — shared references and circular structures round-trip intact.

Decide whether a string matches a pattern containing `?` (any single character) and `*` (any sequence) — a two-dimensional dynamic-programming match over string and pattern.