Data Structures interview questions

Implement a function that checks whether a string of brackets is properly opened and closed in order.

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 merges two sorted linked lists into a single sorted linked list.

Implement a function that returns the elements from the first array that do not appear in the second.

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

Implement a function that returns the unique values present in every input array.

Implement a function that reverses a singly linked list in place and returns the new head.

Build a queue data structure supporting enqueue, dequeue, peek, and size in FIFO order.

Implement a function that returns the element count of any collection — array, string, object, Map, or Set.

Implement a cache whose entries expire a fixed time after their last access, not after being set.

Build a stack data structure that supports the standard push, pop, peek, and size operations.

Implement a function that returns a new array with duplicate values removed while preserving original order.

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.

Build a binary tree data structure with the essential insert, traverse, and search operations.

Implement a function that returns the values of a binary tree grouped by level from top to bottom.

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.

Build a Bloom filter — a compact probabilistic set that answers membership with no false negatives but possible false positives, using a bit array and several hash functions.

Implement breadth-first traversal of a directed graph, visiting nodes level by level from a start vertex.

Build a two-player Connect Four game where discs fall to the lowest empty slot and four-in-a-row wins.

Implement a function that decides whether a set of courses can be finished given their prerequisite pairs.

Implement a function that removes the nth-from-end node from a singly linked list in one pass.

Build a double-ended queue with constant-time push and pop at both the front and the back, backed by a doubly linked list.

Implement an EventEmitter class supporting on, off, and emit to register and trigger listeners.

Implement an event emitter where subscribe returns a handle whose release method removes that listener.

Build a file explorer that renders the tree as a flat DOM list while preserving nested visual structure.

Build increment and decrement counters that merge by per-node maxima into a conflict-free convergent total.

Implement a function that produces a deep copy of a connected, undirected graph given a reference node.

Implement a function that counts the number of connected components in an undirected graph given its edges.

Implement a function that intersects arrays by comparing values produced by an iteratee, keeping uniqueness.

Implement a function that intersects arrays using a user-supplied comparator to decide equality between elements.

Implement a function that determines whether a given undirected graph forms a valid tree.

Build a singly linked list data structure with the standard insert, remove, and traversal operations.

Implement a function that detects whether a singly linked list contains a cycle.

Implement a function that returns the length of the longest run of consecutive integers found in an unsorted array.

Implement a function that returns the length of the longest substring containing no duplicate characters.

Build a last-write-wins map whose entries merge by timestamp with a deterministic node-id tiebreak.

Implement a class that records timestamped writes and returns the most recent value at or before a queried timestamp.

Implement a function that zeroes out every row and column in a matrix that originally contained a zero, ideally in place.

Implement a memoize helper that caches results for functions called with any number and type of arguments.

Build a simplified in-memory ORM with model delegates that expose basic CRUD operations.

Extend a simplified in-memory ORM with richer filtering predicates and multi-field sorting.

Implement a function that returns the k most frequent integers in an array, breaking ties consistently.

Implement a registry that associates values with DOM nodes without leaking memory once nodes are gone.

Store entities flat by id, normalizing nested relations and merging updates immutably.

Build an observed-remove set where a concurrent add and remove converge with the add winning.

Build a FIFO queue out of two LIFO stacks — pour one stack into the other so the reversed order dequeues oldest-first in amortized constant time.

Implement a function that reorders a singly linked list by interleaving nodes from the front and the reversed back half.

Implement a spreadsheet class that resolves numeric cell values and evaluates simple addition formulas.

Build a spreadsheet class that evaluates left-to-right arithmetic formulas referencing other cells.

Implement a function that groups an array of strings so anagrams of each other end up in the same bucket.

Implement a function that overwrites the style on a given text range and normalizes the resulting range list.

Implement a function that schedules tasks with a cooldown between identical ones and returns the minimum total time.

Build a small test runner that supports nested describe suites and reports tests with their full spec names.

Extend a tiny test runner with beforeEach and afterEach hooks that are inherited from outer suites.

Implement a Trie data structure supporting insert, exact word search, and prefix lookup operations.

Implement a class that tracks value history and exposes undo and redo navigation across the timeline.

Build a counter that keeps a history of values so you can undo and redo each change.

Build a user database class that supports CRUD operations plus undo and redo across the operation history.

Implement a function that returns unique values across input arrays using a custom iteratee to determine identity.

Build a disjoint-set structure with near-constant-time union and find, using path compression and union by rank to keep the trees flat.

Implement a hook that wraps a JavaScript Map with set, delete, and clear helpers backed by state.

Implement a function that determines whether a binary tree satisfies the binary search tree ordering invariant.

Implement a data structure that supports adding words and searching with a wildcard character that matches any letter.

Implement a Backbone-style Model class that stores attributes and emits change events per key.

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 functions that convert a binary tree to a string and reconstruct the same tree back from that string.

Extend the classNames utility to dedupe class names and resolve function arguments lazily.

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

Implement Dijkstra's algorithm to compute shortest paths from a source vertex in a weighted graph.

Build an in-memory query builder inspired by Drizzle with table helpers, filters, sorting, and pagination.

Extend an in-memory query builder inspired by Drizzle with select projections and column aliases.

Extend an in-memory query builder inspired by Drizzle with innerJoin and leftJoin between related tables.

Build a Fenwick tree for logarithmic prefix-sum queries and point updates, using the lowest-set-bit trick to walk responsibility ranges.

Implement a function that returns every word from a dictionary that can be traced through adjacent cells in a grid.

Implement a binary heap data structure supporting push, pop, peek, and heapify with the standard ordering invariant.

Implement heap sort by building a max-heap and repeatedly extracting the largest element.

Implement produce so mutating a draft proxy yields a new immutable state with structural sharing.

Build a simplified in-memory ORM with field selection and eagerly included related records.

Implement a data structure that ingests integers one at a time and reports the running median in logarithmic time.

Implement a minimal Observable with subscribe/unsubscribe and of/from plus map and filter operators.

Build an immutable list where every update returns a new version that shares unchanged nodes with the old one — structural sharing over a cons list.

Build a segment tree over an array for logarithmic range-sum queries and point updates, each tree node holding the aggregate of its slice.

Build a replicated growable array for text whose positional-id inserts and deletes converge across replicas.

Build a skip list — a sorted set layered with express lanes of linked lists so search, insert, and delete run in expected logarithmic time.

Build a spreadsheet that recomputes dependent cells when inputs change and detects circular references.

Implement a slice operation over text annotated with overlapping style ranges, preserving alignment.

Implement a function that replaces a text range and keeps the surrounding style ranges normalized.

Implement serialize and deserialize helpers that round-trip values like Date, Map, Set, and BigInt through JSON.

Build a generalized tic-tac-toe game on an N x N board where M consecutive marks wins.

Build a class that tracks draft values and commits them as batch checkpoints for undo and redo navigation.

Build a user database that buffers draft mutations and commits them as batch undo and redo checkpoints.