Copy<\/button><\/div>\n\ndef reverse_iterative(head):\n\n prev = None\n\n current = head\n\n while current:\n\n next_node = current.next\n\n current.next = prev\n\n prev = current\n\n current = next_node\n\n return prev\ndef reverse_recursive(head):\n\n if not head or not head.next:\n\n return head\n\n new_head = reverse_recursive(head.next)\n\n head.next.next = head\n\n head.next = None\n\n return new_head\n<\/code><\/pre><\/div><\/p>\nBoth run in O(n) time. The iterative version is O(1) extra space, the recursive one is O(n) due to the call stack, which matters if the list is long enough to risk a stack overflow. A common mistake is forgetting to null out the old head’s next pointer at the end, which silently creates a cycle back into the original list. If you’re asked to reverse only a sublist between positions m and n, keep a pointer to the node just before m so you can splice the reversed segment back in without losing the rest of the list.<\/p>\n
<\/div><\/div><\/div>\n
<\/span>Medium questions<\/h2>29<\/span><\/div><\/div><\/div>\n
Binary tree vertical order traversal<\/span>Trees \/ BFS<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
BFS with column tracking. Use a queue storing (node, column) pairs, starting at column 0. Left children get column – 1, right children get column + 1. Use a hash map from column to list of node values. After traversal, sort by column key and return the lists in order.<\/p>\n
This is one of the most-reported Meta coding questions across multiple 2024 and 2025 candidate accounts. The BFS approach is cleanest under interview time pressure. DFS works too but requires more careful coordination of levels if the problem asks for top-to-bottom ordering within a column.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\nfrom collections import defaultdict, deque\ndef verticalOrder(root):\n\n if not root:\n\n return []\n\n col_map = defaultdict(list)\n\n queue = deque([(root, 0)])\n\n min_col = max_col = 0\n while queue:\n\n node, col = queue.popleft()\n\n col_map[col].append(node.val)\n\n min_col = min(min_col, col)\n\n max_col = max(max_col, col)\n\n if node.left:\n\n queue.append((node.left, col \u2013 1))\n\n if node.right:\n\n queue.append((node.right, col + 1))\n return [col_map[c] for c in range(min_col, max_col + 1)]\n<\/code><\/pre><\/div>Determine if a binary tree is height-balanced<\/span>Trees \/ DFS<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Bottom-up DFS. For each node, compute the height of left and right subtrees. If either subtree returns -1 (already unbalanced), propagate -1 upward. Otherwise, if the difference in heights exceeds 1, return -1. Otherwise, return 1 + max(left_height, right_height).<\/p>\n
The naive top-down approach that calls height() at each node is O(n^2). The bottom-up version is O(n). Meta interviewers at E5 will notice which you reach for first, and the complexity discussion is part of the expected follow-up. Reported in a 2025 phone screen.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\ndef isBalanced(root):\n\n def check(node):\n\n if not node:\n\n return 0\n\n left = check(node.left)\n\n if left == -1:\n\n return -1\n\n right = check(node.right)\n\n if right == -1:\n\n return -1\n\n if abs(left \u2013 right) > 1:\n\n return -1\n\n return 1 + max(left, right)\n\n return check(root) != -1\n<\/code><\/pre><\/div>Find the lowest common ancestor of two nodes in a binary tree<\/span>Trees \/ DFS<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Recursive DFS. If the current node is null, or is one of the target nodes, return it. Recurse on left and right subtrees. If both return non-null values, the current node is the LCA. If only one returns non-null, propagate that upward.<\/p>\n
Reported from multiple Meta onsites. The follow-up at E5 often pushes toward: “what if the tree is a BST instead?” (use BST properties to skip a subtree) or “what if one node might not exist in the tree?” (need to count how many targets you found before claiming you have an ancestor).<\/p>\n
<\/div><\/div><\/div>\n
Longest substring without repeating characters<\/span>Sliding Window<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Sliding window with a set. Move the right pointer to expand the window, adding each character. When a duplicate is found, move the left pointer rightward, removing characters from the set, until the duplicate is eliminated. Track the maximum window size seen.<\/p>\n
One of the most frequently reported Meta phone screen questions, appearing in candidate accounts from 2024 through 2025. At E5, the coding round is typically problem two after this or something of similar difficulty, so this shows up more in phone screens than onsites.<\/p>\n
<\/div><\/div><\/div>\n
Remove minimum to make valid parentheses<\/span>Stack \/ Strings<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Two-pass approach. First pass: scan left to right, use a stack of open-bracket indices. When you see a closing bracket and the stack is empty, mark it for removal. When you see an opening bracket, push its index. After the first pass, all remaining indices in the stack are unmatched opens, mark them for removal. Build the result string skipping all marked indices.<\/p>\n
This is LeetCode 1249 and one of the single most-reported Meta coding questions in 2024-2025. It appears in both phone screens and onsites. If you prep one string question for Meta, prep this one. Follow-up: “what if you also need to add brackets, not just remove?” takes this into a harder problem (LeetCode 921).<\/p>\n
python<\/span>Copy<\/button><\/div>\n\ndef minRemoveToMakeValid(s):\n\n stack = []\n\n to_remove = set()\n\n for i, c in enumerate(s):\n\n if c == \u2018(\u2018:\n\n stack.append(i)\n\n elif c == \u2018)\u2019:\n\n if stack:\n\n stack.pop()\n\n else:\n\n to_remove.add(i)\n\n to_remove |= set(stack)\n\n return \u201d.join(c for i, c in enumerate(s) if i not in to_remove)\n<\/code><\/pre><\/div>Find the k-th largest element in an array<\/span>Heap<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Min-heap of size k. Iterate through the array. Push each element. If the heap exceeds size k, pop the minimum. At the end, the heap’s minimum is the k-th largest element. O(n log k) time, O(k) space. Alternatively, quickselect gives O(n) average time but O(n) worst case.<\/p>\n
This is LeetCode 215, reported from multiple Meta onsites in 2024-2025. Interviewers at Meta sometimes ask which approach you’d choose and why. Quickselect is the right choice when k is large relative to n; the heap approach wins when you need online processing of a stream.<\/p>\n
<\/div><\/div><\/div>\n
Find the length of the longest subarray with at most k distinct elements<\/span>Sliding Window \/ HashMap<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Sliding window with a character frequency map. Expand right pointer, adding characters to the map. When the map has more than k distinct keys, shrink from the left, decrementing counts and removing keys that hit zero. Track the maximum window length throughout.<\/p>\n
Reported from a 2024 Meta onsite. This is a clean application of the variable sliding window pattern. The map-based approach generalizes better than a set-based approach because you need to know when a character is fully exited from the window.<\/p>\n
<\/div><\/div><\/div>\n
Basic Calculator II (evaluate expression with +, -, *, \/)<\/span>Stack<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Single-pass with a stack. Track the current number and the last seen operator. On ‘+’ or ‘-‘, push the current number (negated for ‘-‘) onto the stack. On ‘*’ or ‘\/’, pop the top of the stack, apply the operator, and push the result. Sum the stack at the end. This handles operator precedence without recursion or building an AST.<\/p>\n
This is LeetCode 227 and a verified Meta interview question. Follow-up at E5: “extend this to handle parentheses” moves it to LeetCode 224 (Basic Calculator), which requires recursive processing or a stack that handles nested expressions. Know both.<\/p>\n
<\/div><\/div><\/div>\n
Number of Islands (count connected regions in a grid)<\/span>Graphs \/ BFS-DFS<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Flood fill. Scan the grid cell by cell. When you hit an unvisited land cell (‘1’), increment the island count and run DFS or BFS from that cell, marking every connected land cell as visited so you don’t count it again. Four-directional adjacency is standard unless the question specifies diagonals.<\/p>\n
This is one of the most consistently tagged Meta questions on LeetCode’s own company-specific problem list, and it shows up often enough as a phone screen opener that some candidates report seeing it twice across different rounds. The follow-up worth prepping: count the number of distinct island shapes, which needs you to normalize each island’s cell coordinates relative to its top-left corner before comparing shapes.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\ndef numIslands(grid):\n\n if not grid:\n\n return 0\n\n rows, cols = len(grid), len(grid[0])\n\n count = 0\n def dfs(r, c):\n\n if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] != \u20181\u2019:\n\n return\n\n grid[r][c] = \u20180\u2019\n\n dfs(r + 1, c)\n\n dfs(r \u2013 1, c)\n\n dfs(r, c + 1)\n\n dfs(r, c \u2013 1)\n for r in range(rows):\n\n for c in range(cols):\n\n if grid[r][c] == \u20181\u2019:\n\n count += 1\n\n dfs(r, c)\n\n return count\n<\/code><\/pre><\/div>Clone a graph (deep copy with cycles)<\/span>Graphs \/ DFS<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
DFS or BFS with a hash map from original node to its clone. Start at the given node, create its clone, then for each neighbor: if it’s already in the map, wire up the reference; if not, recurse into it first. The map is what keeps cycles from causing infinite recursion, since a node already being cloned is a signal to stop and reuse the existing clone.<\/p>\n
Reported across multiple 2024 and 2025 Meta phone screens, often paired with a linked list question as problem two. Interviewers sometimes ask you to do it iteratively with an explicit stack instead of recursion, mostly to see if you understand why the hash map matters rather than just reciting the recursive template.<\/p>\n
<\/div><\/div><\/div>\n
Course Schedule (can you finish all courses given prerequisites)<\/span>Graphs \/ Topological Sort<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
Build an adjacency list from the prerequisite pairs and track in-degree per course. Use Kahn’s algorithm: push every course with in-degree zero onto a queue, pop each one, decrement the in-degree of its neighbors, and push any neighbor that drops to zero. If you process every course this way, there’s no cycle and the answer is true. If courses remain unprocessed, a cycle exists somewhere in that subset.<\/p>\n
This tests whether topological sort is a pattern you reach for automatically instead of trying to brute-force a cycle check with repeated DFS calls. Meta sometimes reskins it as a build-dependency or task-scheduling system, same underlying graph.<\/p>\n
python<\/span>Copy<\/button><\/div>\n\nfrom collections import deque, defaultdict\ndef canFinish(numCourses, prerequisites):\n\n graph = defaultdict(list)\n\n indegree = [0] * numCourses\n\n for course, prereq in prerequisites:\n\n graph[prereq].append(course)\n\n indegree[course] += 1\n queue = deque([c for c in range(numCourses) if indegree[c] == 0])\n\n processed = 0\n\n while queue:\n\n node = queue.popleft()\n\n processed += 1\n\n for neighbor in graph[node]:\n\n indegree[neighbor] -= 1\n\n if indegree[neighbor] == 0:\n\n queue.append(neighbor)\n\n return processed == numCourses\n<\/code><\/pre><\/div>Copy a linked list with random pointers<\/span>Linked Lists<\/span>Medium<\/span><\/span><\/span><\/button><\/p>\n
The O(1)-space trick: interleave a clone of each node right after its original (A -> A’ -> B -> B’ -> C -> C’), then set each clone’s random pointer using original.random.next, since the clone of any node always sits directly after it. Finally, unweave the list back into two separate lists. A hash map from original node to clone works too and is easier to explain under pressure, at the cost of O(n) extra space.<\/p>\n
A recurring Meta-tagged linked list question. Interviewers generally accept the hash map solution as a correct starting point, then ask whether you can do it without extra space, which is where the interleaving approach comes in.<\/p>\n
<\/div><\/div><\/div>\n
Merge overlapping intervals<\/span>