Algorithms and Data Structures

Break an interview prompt into inputs, outputs, constraints, and edge cases.

Translate a step-by-step algorithm into an executable Python function using parameters, conditionals, loops, and return values.

Trace an unfamiliar Python algorithm by hand to determine its output.

Construct boundary and adversarial test cases for a Python function.

Determine and express in Big-O notation the time complexity of algorithms containing sequential, nested, and input-halving loops.

Determine the auxiliary-space complexity of an algorithm.

Compare candidate algorithms using input constraints and time–space trade-offs.

Explain why repeated appends to a Python list have amortized constant cost.

Predict the time and space costs of indexing, slicing, appending, inserting, and deleting in Python lists and strings.

Compute an aggregate over an array with a single traversal.

Modify an array in place using separate read and write indices.

Solve an ordered-array problem using pointers moving from opposite ends.

Compute values over fixed-size windows without recomputing each window.

Maintain a valid variable-size sliding window as its boundaries move.

Answer range-sum queries using a prefix-sum array.

Traverse a two-dimensional grid without missing or revisiting cells.

Explain how hash tables support average constant-time lookup and why collisions affect worst-case performance.

Build a frequency table with a Python dictionary or Counter.

Use a set to detect duplicates and perform fast membership tests.

Find a complementary value or index with a one-pass hash-map lookup.

Group values by a computed key using a dictionary.

Track the earliest or latest position of each value with a dictionary.

Test, set, clear, and toggle individual bits with bitwise operators.

Use XOR cancellation to find an unmatched value.

Represent and traverse a singly linked list in Python.

Insert and delete a singly linked-list node by updating links safely.

Reverse a singly linked list iteratively.

Find the middle node of a singly linked list using fast and slow pointers.

Detect a cycle in a singly linked list using fast and slow pointers.

Implement last-in-first-out behavior with a Python list.

Validate nested delimiters with a stack.

Implement first-in-first-out behavior with collections.deque.

Trace recursive calls and returns using a call-stack diagram.

Define a terminating base case and a size-reducing recursive case.

Generate all subsets of a sequence with backtracking.

Generate all permutations of distinct values with backtracking.

Generate combinations that satisfy a target constraint.

Prune a backtracking search when a partial candidate cannot lead to a solution.

Estimate the time and space complexity of a recursive search tree.

Sort Python records with a key function and use sort stability deliberately.

Implement merge sort and derive its time and auxiliary-space complexity.

Implement binary search for an exact value in a sorted sequence.

Find the first or last valid position with boundary-based binary search.

Search a rotated sorted array by identifying which half is ordered.

Apply binary search to a monotonic answer space.

Choose between hashing and sorting for a lookup-oriented problem.

Represent a binary tree and identify parent, child, leaf, depth, and height relationships.

Implement and contrast recursive preorder, inorder, and postorder traversals of a binary tree.

Traverse a binary tree level by level with a queue.

Compute the maximum depth of a binary tree using postorder recursion.

Determine whether a binary tree is height-balanced using bottom-up depth checks.

Find the lowest common ancestor of two nodes in a binary tree.

Search and insert values in a binary search tree.

Validate the ordering invariant of a binary search tree using bounds or inorder traversal.

Explain the heap-order invariant and the array representation of a binary heap.

Use heapq to insert and remove priority-ordered items.

Find the largest or smallest k items with a bounded heap.

Merge multiple sorted sequences with a heap.

Insert words into a trie.

Implement exact-word and prefix lookup in a trie.

Implement node insertion and deletion in a doubly linked list with dummy head and tail nodes.

Implement constant-time get and put operations in an LRU cache by combining a hash map with a doubly linked list.

Convert relationship data into an adjacency-list graph.

Traverse a graph with depth-first search while preventing repeated visits.

Find shortest path lengths in an unweighted graph with breadth-first search.

Count connected regions in a grid by modeling cells as graph vertices.

Detect a cycle in a directed graph using visitation states.

Produce a topological ordering of a directed acyclic graph.

Maintain dynamic connectivity with a disjoint-set union structure.

Find shortest paths with nonnegative edge weights using Dijkstra’s algorithm.

Find next-greater elements with a monotonic stack.

Merge overlapping intervals after sorting them.

Compute the maximum number of simultaneous intervals using ordered events.

Disprove an invalid greedy strategy by constructing a counterexample.

Select the maximum number of mutually compatible intervals using the earliest-finish-time rule.

Justify the earliest-finish-time interval strategy with an exchange argument.

Find the minimum jumps through an array using greedy range expansion.

Match sorted tasks and resources using a greedy selection rule.

Recognize overlapping subproblems and optimal substructure in a problem statement.

Define a dynamic-programming state and recurrence for a one-dimensional problem.

Convert a recursive recurrence into a memoized Python solution.

Convert a memoized solution into a bottom-up table.

Solve a minimum-coin problem with dynamic programming.

Solve a grid-path problem with dynamic programming.

Solve a 0/1 selection problem with knapsack-style dynamic programming.

Compute the length of a longest common subsequence with dynamic programming.

Derive a more efficient solution by identifying the bottleneck in a brute-force approach.

Select a data structure from problem constraints and justify the choice.

Explain an algorithm and its complexity before writing code.

Debug a failing algorithm by constructing a minimal counterexample.

Solve a timed intermediate array-or-hashing interview problem in Python.

Solve a timed problem that requires tree or graph traversal in Python.

Solve a timed one-dimensional dynamic-programming interview problem in Python.

Review a mock-interview solution and record reusable lessons from its errors.