Q: Explain the Two Pointer technique with an example.

Two pointers are indices that start at different positions and move toward/away from each other to solve array problems in O(n) instead of O(n²).

Q: What is a Heap? How does a Priority Queue work?

A heap is a complete binary tree satisfying the heap property: max-heap has parent ≥ children. It provides O(1) peek at max/min and O(log n) insert/delete. Priority Queues are typically implemented with heaps.

Q: What is the difference between a Stack and a Queue? Give real use cases.

A Stack is LIFO (Last-In-First-Out) — the most recently added element is removed first. A Queue is FIFO (First-In-First-Out) — the oldest element is removed first. Both support O(1) push/pop when implemented correctly.

Q: What is a Trie (Prefix Tree)? When would you use one over a HashSet?

A Trie is a tree where each path from the root spells out a prefix of stored strings. Each node represents one character, and a flag marks the end of a complete word. It enables O(L) insert/search/prefix-lookup, where L is the string length — independent of how many words are stored.

Question 1

What is the difference between an Array and a Linked List?

Accepted Answer

Arrays store elements in contiguous memory with O(1) random access. Linked Lists store elements in nodes with pointers, offering O(1) insertions/deletions but O(n) access.

Question 2

Explain how a Hash Map works internally.

Accepted Answer

A hash map uses a hash function to convert keys into array indices. Collisions are handled via chaining (linked list per bucket) or open addressing. Average case O(1) for get/put.

Question 3

What is Dynamic Programming? How do you identify a DP problem?

Accepted Answer

DP solves problems by breaking them into overlapping subproblems and storing results to avoid recomputation. Identify it when you see optimal substructure + overlapping subproblems.

Question 4

Explain BFS vs DFS and when to use each.

Accepted Answer

BFS explores level by level using a queue — best for shortest path in unweighted graphs. DFS explores depth-first using a stack/recursion — best for cycle detection, topological sort, and exhaustive search.

Question 5

What is the time complexity of common sorting algorithms?

Accepted Answer

QuickSort averages O(n log n), MergeSort is always O(n log n) but uses O(n) space, HeapSort is O(n log n) in-place. Counting/Radix Sort achieve O(n) for specific inputs.

Question 6

What is a Binary Search Tree (BST)? What are its time complexities?

Accepted Answer

A BST is a binary tree where every left child < parent < right child. Search, insert, delete are O(h) where h is height — O(log n) for balanced, O(n) worst case (degenerate/skewed tree).

Question 7

Explain the Two Pointer technique with an example.

Accepted Answer

Two pointers are indices that start at different positions and move toward/away from each other to solve array problems in O(n) instead of O(n²).

Question 8

What is a Heap? How does a Priority Queue work?

Accepted Answer

A heap is a complete binary tree satisfying the heap property: max-heap has parent ≥ children. It provides O(1) peek at max/min and O(log n) insert/delete. Priority Queues are typically implemented with heaps.

Question 9

What is the difference between a Stack and a Queue? Give real use cases.

Accepted Answer

A Stack is LIFO (Last-In-First-Out) — the most recently added element is removed first. A Queue is FIFO (First-In-First-Out) — the oldest element is removed first. Both support O(1) push/pop when implemented correctly.

Question 10

What is a Trie (Prefix Tree)? When would you use one over a HashSet?

Accepted Answer

A Trie is a tree where each path from the root spells out a prefix of stored strings. Each node represents one character, and a flag marks the end of a complete word. It enables O(L) insert/search/prefix-lookup, where L is the string length — independent of how many words are stored.

Question 11

What is Union-Find (Disjoint Set Union)? How do path compression and union by rank work?

Accepted Answer

Union-Find tracks a collection of disjoint sets with two operations: find(x) returns the representative ("root") of x's set, and union(x, y) merges the sets containing x and y. With path compression and union by rank/size, both operations run in nearly O(1) amortized — technically O(α(n)), the inverse Ackermann function.

Question 12

Beyond a simple lookup, what are the common Binary Search variations?

Accepted Answer

Binary search isn't just "find this exact value" — the same divide-and-halve idea also finds the first/last occurrence of a value, locates a pivot in a rotated sorted array, and can search an "answer space" for the smallest value that satisfies a condition (binary search on the answer).

Question 13

Recursion vs Iteration — what are the trade-offs, and how do you convert one to the other?

Accepted Answer

Recursion solves a problem by having a function call itself on smaller subproblems until a base case is reached; iteration uses loops. Recursion is often more readable for trees, graphs, and divide-and-conquer, but each call adds a stack frame — O(depth) space and a real risk of "Maximum call stack size exceeded". Any recursive algorithm can be rewritten iteratively using an explicit stack.

Question 14

What is Backtracking? Walk through the "choose, explore, un-choose" template.

Accepted Answer

Backtracking is depth-first search over a tree of partial solutions: at each step you make a choice, recurse deeper, and if that path can't lead to a valid answer you undo ("backtrack") the choice and try the next option. It's how you systematically generate permutations, combinations, subsets, and solve constraint problems like N-Queens or Sudoku.

Question 15

What is a Greedy algorithm? When does the greedy approach fail?

Accepted Answer

A greedy algorithm makes the locally optimal choice at every step, hoping it adds up to a globally optimal solution. It only works when the problem has the "greedy choice property" (a local best choice is always part of some global optimum) AND "optimal substructure". When those don't hold, greedy gives a wrong answer and you need DP instead.

Question 16

What are common Bit Manipulation tricks used in interviews?

Accepted Answer

Bitwise operators (&, |, ^, ~, <<, >>) let you solve certain problems in O(1) extra space and very fast constant time. The most common interview tricks: XOR to find a unique element, n & (n-1) to drop the lowest set bit (for counting bits or checking powers of two), n & -n to isolate the lowest set bit, and bitmasks to represent subsets/state in DP.

Question 17

Explain the Sliding Window technique — fixed-size vs variable-size windows.

Accepted Answer

Sliding Window turns nested-loop subarray/substring problems (O(n²) or worse) into a single O(n) pass by maintaining a "window" of elements and incrementally updating its state as the window slides. A fixed-size window has a constant width; a variable-size window grows/shrinks based on a constraint.

Question 18

How do you represent a graph in code? Adjacency List vs Adjacency Matrix vs Edge List.

Accepted Answer

Adjacency Matrix is a V×V grid giving O(1) edge lookups but O(V²) space — good for dense graphs. Adjacency List stores, per vertex, only its neighbors — O(V+E) space, ideal for the sparse graphs most real-world problems use. Edge List is just a flat list of (u, v, weight) triples — simplest, and perfect when you need to sort all edges (e.g., Kruskal's algorithm).

Question 19

Explain Dijkstra's Algorithm — how does it find the shortest path, and why doesn't it work with negative weights?

Accepted Answer

Dijkstra's algorithm finds the shortest path from a source to all other nodes in a weighted graph with non-negative edge weights. It greedily picks the unvisited node with the smallest known distance, "finalizes" it, and relaxes (updates) the distances of its neighbors. A min-heap (priority queue) makes this O((V+E) log V).

Question 20

What is Topological Sort? Compare the BFS (Kahn's) and DFS approaches.

Accepted Answer

Topological sort produces a linear ordering of vertices in a Directed Acyclic Graph (DAG) such that for every edge u→v, u comes before v. It only exists if the graph has NO cycles. The two standard approaches are Kahn's algorithm (BFS using in-degrees) and DFS (push nodes onto a stack after exploring all their descendants, then reverse).

Question 21

What is a Minimum Spanning Tree? Compare Kruskal's and Prim's algorithms.

Accepted Answer

A Minimum Spanning Tree (MST) connects all vertices of a weighted, undirected graph with the minimum total edge weight, using exactly V-1 edges and no cycles. Kruskal's algorithm sorts ALL edges and greedily adds the smallest one that doesn't form a cycle (using Union-Find). Prim's algorithm grows a single tree from a start node, always adding the cheapest edge connecting the tree to a new vertex (using a priority queue).

Question 22

What is the Floyd-Warshall algorithm? When would you use it instead of running Dijkstra from every node?

Accepted Answer

Floyd-Warshall computes the shortest path between EVERY pair of vertices in O(V³) using dynamic programming. The core idea: for each intermediate vertex k, check if going through k gives a shorter path between every pair (i, j). It works with negative edge weights (but not negative cycles) and is simpler to implement than running Dijkstra V times.

Question 23

How do you detect a cycle in a graph? Explain for both directed and undirected graphs.

Accepted Answer

For UNDIRECTED graphs, use DFS tracking the parent — if you reach a visited node that ISN'T the parent, there's a cycle (or use Union-Find: if two nodes of an edge are already in the same set, adding that edge creates a cycle). For DIRECTED graphs, you must track the current DFS recursion path (a "gray" set) — if you reach a node that's currently in the recursion stack, there's a cycle. Simply checking "visited" is NOT enough for directed graphs.

Question 24

How does a Heap work? How do you find the k-th largest element using one?

Accepted Answer

A heap is a complete binary tree stored efficiently in an array, satisfying the heap property: in a min-heap, every parent is ≤ its children (so the minimum is always at the root); in a max-heap, every parent is ≥ its children. Insert and extract-min/max are O(log n) via "sift up"/"sift down". For the k-th largest element, maintain a min-heap of size k — the root is always the answer.

Question 25

What is the Two-Pointer technique? How is it different from Sliding Window?

Accepted Answer

Two-Pointer uses two indices traversing a (usually sorted) array or string to avoid nested loops — either moving toward each other from opposite ends, or moving in the same direction at different speeds (fast/slow). It's different from Sliding Window in intent: two-pointer often searches for a PAIR or checks a property by converging, while sliding window tracks a contiguous RANGE that grows/shrinks based on a constraint.

Question 26

What is Prefix Sum and how does a Difference Array enable O(1) range updates?

Accepted Answer

A prefix sum array stores cumulative sums so any range-sum query (l, r) becomes O(1): prefix[r] - prefix[l-1]. A difference array is the inverse idea — it lets you apply a value to an ENTIRE RANGE in O(1) by only touching the two endpoints, then reconstruct the final array with one prefix-sum pass at the end.

Question 27

Design an LRU (Least Recently Used) Cache with O(1) get and put operations.

Accepted Answer

An LRU Cache combines a HashMap (key → node reference, for O(1) lookup) with a Doubly Linked List (to maintain usage order, with O(1) move-to-front and O(1) eviction from the tail). On `get`, move the accessed node to the front (most recently used). On `put`, insert at the front; if over capacity, evict the node at the tail (least recently used).

Question 28

What is a Fenwick Tree (Binary Indexed Tree)? How does it compare to a Segment Tree?

Accepted Answer

Both Fenwick Trees (Binary Indexed Trees / BIT) and Segment Trees support range queries and point updates in O(log n), replacing O(n) per operation on a plain array. A Fenwick Tree is a compact array using bit tricks (i & -i) — simple to code, but limited mainly to prefix-sum-style operations. A Segment Tree is a more general binary tree supporting ANY associative operation (min, max, GCD, sum) and range updates via lazy propagation, at the cost of more code.

Question 29

What are the common Matrix Traversal patterns? (Spiral order, rotate image, flood fill)

Accepted Answer

Matrix problems usually fall into a few recurring patterns: boundary-shrinking traversal (spiral order), in-place transformation via layer-by-layer swaps (rotate image), and connected-component exploration (flood fill / number of islands using BFS or DFS). Recognizing which pattern applies is more important than memorizing code.

Question 30

BFS vs DFS — when do you use one over the other?

Accepted Answer

BFS (Breadth-First Search) explores level-by-level using a queue — ideal for finding the SHORTEST PATH in an unweighted graph, since the first time you reach a node is guaranteed to be via the shortest route. DFS (Depth-First Search) explores as deep as possible using a stack (or recursion) — ideal for exploring ALL paths, detecting cycles, topological sort, and problems with backtracking.

Question 31

Explain the 0/1 Knapsack DP pattern and how to optimize its space complexity.

Accepted Answer

0/1 Knapsack: given items with weights and values, and a capacity W, maximize total value without exceeding W — each item can be taken AT MOST ONCE (0 or 1, no fractions). The DP state is dp[i][w] = max value using the first i items with capacity w, with the recurrence dp[i][w] = max(dp[i-1][w], dp[i-1][w-weight[i]] + value[i]). The 2D table can be optimized to a 1D array by iterating capacity in REVERSE.

Question 32

Explain the DP for Longest Common Subsequence (LCS) and Edit Distance.

Accepted Answer

LCS finds the longest sequence of characters (not necessarily contiguous) that appears in both strings, in the same relative order. Edit Distance finds the minimum number of insert/delete/replace operations to transform one string into another. Both use a 2D DP table dp[i][j] representing "the answer for the first i characters of string A and first j characters of string B", with recurrences based on whether characters match.

Question 33

How do you find the Longest Increasing Subsequence (LIS)? Explain both the O(n²) and O(n log n) approaches.

Accepted Answer

LIS finds the length of the longest subsequence (not necessarily contiguous) where elements are strictly increasing. The O(n²) DP approach computes dp[i] = length of the LIS ending at index i, checking all previous elements. The O(n log n) approach maintains an array of "smallest tail values" for increasing subsequences of each length, using binary search to find where each new element fits.

Question 34

How does the KMP (Knuth-Morris-Pratt) string matching algorithm achieve O(n+m) time?

Accepted Answer

Naive string matching re-checks from scratch after every mismatch — O(n×m) worst case. KMP precomputes an LPS (Longest Proper Prefix which is also Suffix) array for the pattern in O(m), which tells it exactly how far to "shift" the pattern after a mismatch WITHOUT re-examining characters in the text it has already matched — giving O(n+m) total.

Question 35

What is a Monotonic Stack and what problems does it solve?

Accepted Answer

A monotonic stack maintains its elements in strictly increasing or decreasing order. Whenever a new element would violate that order, you pop elements until the order is restored — and each POP gives you useful information ("the next greater/smaller element" for the popped item). This turns O(n²) "for each element, scan the rest" problems into O(n).

Question 36

How do you solve Interval problems like Merge Intervals and Meeting Rooms?

Accepted Answer

Almost all interval problems start the same way: SORT the intervals (usually by start time). Once sorted, "Merge Intervals" becomes a single linear pass comparing each interval to the last merged one. "Meeting Rooms II" (minimum rooms needed) becomes a sweep-line problem: track how many meetings are simultaneously active using a min-heap of end times or by separately sorting start/end events.

Question 37

What are the essential Linked List techniques? (Reversal, merge two sorted lists, merge k sorted lists, find middle)

Accepted Answer

Linked list problems revolve around careful pointer manipulation: reversal (iterative with three pointers: prev/curr/next, or recursive), merging two sorted lists (dummy head + comparison), merging k sorted lists (min-heap of current heads, or divide-and-conquer pairwise merging), and finding the middle (slow/fast pointers — same technique as cycle detection).

Question 38

How do you find the Lowest Common Ancestor (LCA) and the Diameter of a Binary Tree, and how do you serialize/deserialize one?

Accepted Answer

LCA: recursively search both subtrees for the two target nodes — if a node's left AND right subtrees both return "found", that node IS the LCA; otherwise propagate whichever side found something. Diameter (longest path between any two nodes, may not pass through root): for each node, compute left height + right height — track the maximum across all nodes during a single post-order traversal. Serialize/deserialize: pre-order traversal with explicit "null" markers lets you reconstruct the exact tree structure.

Question 39

How does Hashing work? How do hash maps handle collisions?

Accepted Answer

A hash function converts a key into an array index (a "bucket"). Since infinite possible keys map to a finite number of buckets, COLLISIONS (two different keys hashing to the same bucket) are inevitable. The two main resolution strategies are chaining (each bucket holds a linked list/array of entries) and open addressing (probe for the next free bucket using linear/quadratic/double hashing). A good hash function distributes keys uniformly to keep buckets small, giving average O(1) operations.

Question 40

What common Math algorithms come up in interviews? (GCD/LCM, Sieve of Eratosthenes, Modular Exponentiation)

Accepted Answer

GCD (greatest common divisor) is computed efficiently with the Euclidean algorithm: gcd(a,b) = gcd(b, a%b), in O(log(min(a,b))). LCM = (a×b)/gcd(a,b). The Sieve of Eratosthenes finds all primes up to N in O(N log log N) by marking multiples of each prime as composite. Modular exponentiation computes (base^exp) % mod in O(log exp) using "binary exponentiation" — squaring the base and halving the exponent.

Question 41

Compare sorting algorithms: QuickSort, MergeSort, and HeapSort. When would you choose each?

Accepted Answer

QuickSort is usually the FASTEST in practice (great cache locality, in-place) but has O(n²) worst case and is NOT stable. MergeSort guarantees O(n log n) always and IS stable, but needs O(n) extra space. HeapSort guarantees O(n log n) and is in-place (O(1) extra space) but is NOT stable and has poor cache locality. The choice depends on whether you need stability, worst-case guarantees, or memory constraints.

Question 42

How does Quickselect find the k-th smallest/largest element in O(n) average time?

Accepted Answer

Quickselect is QuickSort's partition step applied selectively: partition the array around a pivot, then recurse into ONLY the side that contains the k-th element (not both sides like QuickSort). This gives O(n) average time (vs O(n log n) for sort-then-index), because the work HALVES each recursion instead of branching into two recursive calls. Worst case is O(n²) with bad pivots, same mitigation as QuickSort: random/median-of-three pivot selection.

Question 43

Explain Big-O notation deeply — what is Amortized Analysis, and why is dynamic array "push" considered O(1)?

Accepted Answer

Big-O describes how an algorithm's running time grows with input size, ignoring constants and lower-order terms — it's about SCALABILITY, not raw speed. Amortized analysis looks at the AVERAGE cost per operation over a SEQUENCE of operations, even if individual operations occasionally cost more. A dynamic array's push() is "amortized O(1)" because occasional O(n) resizes (doubling capacity) are so infrequent that their cost, spread across all the O(1) pushes between resizes, averages out to O(1) per push.

Question 44

What is a Trie (Prefix Tree)? How would you implement autocomplete with one?

Accepted Answer

A Trie is a tree where each node represents a CHARACTER, and paths from the root spell out PREFIXES of stored strings. Each node has up to 26 (or alphabet-size) children plus a flag marking "a complete word ends here". Lookups, insertions, and prefix searches are all O(L) where L is the string length — independent of how many words are stored. This makes it ideal for autocomplete: walk down the trie following the typed prefix, then DFS from that node to collect all words below it.

Question 45

How do you find the maximum in every sliding window of size k using a Monotonic Deque?

Accepted Answer

Maintain a deque (double-ended queue) of INDICES, kept in DECREASING order of their values — so the front always holds the index of the current window's maximum. For each new element, pop smaller elements off the BACK (they can never be the max while this larger element is in the window), push the new index, then pop the FRONT if it has fallen out of the window. Each index is pushed and popped at most once, giving O(n) total time despite the nested-looking loop.

Question 46

How do you adapt Binary Search for problems beyond "find a value in a sorted array"? (Rotated Arrays, Binary Search on Answer)

Accepted Answer

Binary search works on ANY monotonic (sorted-like) condition, not just sorted arrays. For ROTATED sorted arrays, at each step at least ONE half (left or right of mid) is guaranteed to be normally sorted — check which half is sorted, then determine if the target lies within that sorted half's range. For "BINARY SEARCH ON THE ANSWER" problems (e.g., "minimum capacity to ship packages within D days"), binary search over the RANGE OF POSSIBLE ANSWERS, using a feasibility check (can this value work?) as the comparison — this works whenever feasibility is monotonic (if X works, every value > X also works, or vice versa).

Question 47

How do you apply Dynamic Programming to tree problems? (House Robber III, Tree Diameter)

Accepted Answer

Tree DP works by having each node's recursive call RETURN one or more values summarizing the best results for its subtree, which the PARENT combines. For "House Robber III" (can't rob two directly-connected nodes), each node returns a pair: [best result if this node IS robbed, best result if NOT robbed] — the parent picks whichever combination is valid and optimal. For Tree Diameter, each node returns its HEIGHT, while a side effect/global variable tracks the maximum diameter seen (left height + right height + 1) across all nodes.

Question 48

How do you find the Longest Palindromic Substring? Compare Expand-Around-Center with Dynamic Programming.

Accepted Answer

Expand-Around-Center treats each index (and each gap between indices, for even-length palindromes) as a potential CENTER, and expands outward while characters match — O(n²) time, O(1) space. The DP approach builds a 2D table where dp[i][j] = true if substring s[i..j] is a palindrome, using the recurrence dp[i][j] = (s[i] === s[j]) AND dp[i+1][j-1] — also O(n²) time but O(n²) space. Expand-Around-Center is preferred in practice for its O(1) space; Manacher's Algorithm achieves O(n) but is rarely expected in interviews.

Question 49

How do you check if a Graph is Bipartite? Explain using BFS/DFS Graph Coloring.

Accepted Answer

A graph is bipartite if its vertices can be split into two groups such that every edge connects vertices from DIFFERENT groups (no edge within the same group). To check this, try to 2-COLOR the graph: BFS or DFS from each unvisited node, assigning alternating colors (0/1) to neighbors. If you ever find an edge connecting two same-colored vertices, the graph is NOT bipartite. Equivalently: a graph is bipartite if and only if it contains NO ODD-LENGTH CYCLE.

Question 50

How do you design data structures like Min Stack or LRU-style "Design" problems? What's the general approach?

Accepted Answer

"Design" problems ask you to build a data structure supporting a SET of operations, each with a required time complexity (usually O(1) or O(log n)). The general strategy: identify which operations need to be FAST, then pick (or COMBINE) underlying structures that support each — often a hash map for O(1) lookup PAIRED with an array/list/heap for ordering. For Min Stack specifically: maintain a SECOND stack that tracks the minimum-so-far at each level, so getMin() is O(1) without scanning.

Data Structures & Algorithms

What is the difference between an Array and a Linked List?

Explain how a Hash Map works internally.

What is Dynamic Programming? How do you identify a DP problem?

Explain BFS vs DFS and when to use each.

What is the time complexity of common sorting algorithms?

What is a Binary Search Tree (BST)? What are its time complexities?

Explain the Two Pointer technique with an example.

What is a Heap? How does a Priority Queue work?

What is the difference between a Stack and a Queue? Give real use cases.

What is a Trie (Prefix Tree)? When would you use one over a HashSet?

What is Union-Find (Disjoint Set Union)? How do path compression and union by rank work?

Beyond a simple lookup, what are the common Binary Search variations?

Recursion vs Iteration — what are the trade-offs, and how do you convert one to the other?

What is Backtracking? Walk through the "choose, explore, un-choose" template.

What is a Greedy algorithm? When does the greedy approach fail?

What are common Bit Manipulation tricks used in interviews?

Explain the Sliding Window technique — fixed-size vs variable-size windows.

How do you represent a graph in code? Adjacency List vs Adjacency Matrix vs Edge List.

Explain Dijkstra's Algorithm — how does it find the shortest path, and why doesn't it work with negative weights?

What is Topological Sort? Compare the BFS (Kahn's) and DFS approaches.

What is a Minimum Spanning Tree? Compare Kruskal's and Prim's algorithms.

What is the Floyd-Warshall algorithm? When would you use it instead of running Dijkstra from every node?

How do you detect a cycle in a graph? Explain for both directed and undirected graphs.

How does a Heap work? How do you find the k-th largest element using one?

What is the Two-Pointer technique? How is it different from Sliding Window?

What is Prefix Sum and how does a Difference Array enable O(1) range updates?

Design an LRU (Least Recently Used) Cache with O(1) get and put operations.

What is a Fenwick Tree (Binary Indexed Tree)? How does it compare to a Segment Tree?

What are the common Matrix Traversal patterns? (Spiral order, rotate image, flood fill)

BFS vs DFS — when do you use one over the other?

Explain the 0/1 Knapsack DP pattern and how to optimize its space complexity.

Explain the DP for Longest Common Subsequence (LCS) and Edit Distance.

How do you find the Longest Increasing Subsequence (LIS)? Explain both the O(n²) and O(n log n) approaches.

How does the KMP (Knuth-Morris-Pratt) string matching algorithm achieve O(n+m) time?

What is a Monotonic Stack and what problems does it solve?

How do you solve Interval problems like Merge Intervals and Meeting Rooms?

What are the essential Linked List techniques? (Reversal, merge two sorted lists, merge k sorted lists, find middle)

How do you find the Lowest Common Ancestor (LCA) and the Diameter of a Binary Tree, and how do you serialize/deserialize one?

How does Hashing work? How do hash maps handle collisions?

What common Math algorithms come up in interviews? (GCD/LCM, Sieve of Eratosthenes, Modular Exponentiation)

Compare sorting algorithms: QuickSort, MergeSort, and HeapSort. When would you choose each?

How does Quickselect find the k-th smallest/largest element in O(n) average time?

Explain Big-O notation deeply — what is Amortized Analysis, and why is dynamic array "push" considered O(1)?

What is a Trie (Prefix Tree)? How would you implement autocomplete with one?

How do you find the maximum in every sliding window of size k using a Monotonic Deque?

How do you adapt Binary Search for problems beyond "find a value in a sorted array"? (Rotated Arrays, Binary Search on Answer)

How do you apply Dynamic Programming to tree problems? (House Robber III, Tree Diameter)

How do you find the Longest Palindromic Substring? Compare Expand-Around-Center with Dynamic Programming.

How do you check if a Graph is Bipartite? Explain using BFS/DFS Graph Coloring.

How do you design data structures like Min Stack or LRU-style "Design" problems? What's the general approach?

Practice & learn this topic

Data Structures & Algorithms

What is the difference between an Array and a Linked List?

Explain how a Hash Map works internally.

What is Dynamic Programming? How do you identify a DP problem?

Explain BFS vs DFS and when to use each.

What is the time complexity of common sorting algorithms?

What is a Binary Search Tree (BST)? What are its time complexities?

Explain the Two Pointer technique with an example.

What is a Heap? How does a Priority Queue work?

What is the difference between a Stack and a Queue? Give real use cases.

What is a Trie (Prefix Tree)? When would you use one over a HashSet?

What is Union-Find (Disjoint Set Union)? How do path compression and union by rank work?

Beyond a simple lookup, what are the common Binary Search variations?

Recursion vs Iteration — what are the trade-offs, and how do you convert one to the other?

What is Backtracking? Walk through the "choose, explore, un-choose" template.

What is a Greedy algorithm? When does the greedy approach fail?

What are common Bit Manipulation tricks used in interviews?

Explain the Sliding Window technique — fixed-size vs variable-size windows.

How do you represent a graph in code? Adjacency List vs Adjacency Matrix vs Edge List.

Explain Dijkstra's Algorithm — how does it find the shortest path, and why doesn't it work with negative weights?

What is Topological Sort? Compare the BFS (Kahn's) and DFS approaches.

What is a Minimum Spanning Tree? Compare Kruskal's and Prim's algorithms.

What is the Floyd-Warshall algorithm? When would you use it instead of running Dijkstra from every node?

How do you detect a cycle in a graph? Explain for both directed and undirected graphs.

How does a Heap work? How do you find the k-th largest element using one?

What is the Two-Pointer technique? How is it different from Sliding Window?

What is Prefix Sum and how does a Difference Array enable O(1) range updates?

Design an LRU (Least Recently Used) Cache with O(1) get and put operations.