Data Structures & Algorithms Interview Questions

The core difference lies in their memory allocation and structure. An Array is a static data structure with elements stored in contiguous (side-by-side) memory blocks. A Linked List is dynamic, with elements stored in nodes scattered across memory, connected by pointers.

Both are linear data structures, but they differ in how elements are added and removed. A Stack follows a Last-In, First-Out (LIFO) principle, like a stack of plates. A Queue follows a First-In, First-Out (FIFO) principle, like a checkout line.

A Binary Search Tree is a specialized Tree that maintains a sorted order of its nodes. This structure allows for very fast lookups, insertions, and deletions (O(log n) on average). It must satisfy three properties for every node:

• All values in the node's left subtree must be less than the node's own value.
• All values in the node's right subtree must be greater than the node's own value.
• Both the left and right subtrees must also be binary search trees.

Hashing in Data Structures provides a way to map keys to values for highly efficient lookups. It uses a hash function to compute an index (a "bucket") from a key, where the value is then stored.

A collision occurs when two different keys hash to the same index. This is a common problem that can be resolved using techniques like Chaining (storing a linked list at each index) or Open Addressing (finding the next empty slot).

For a Tree data structure, there are two main approaches: Depth-First Search (DFS) and Breadth-First Search (BFS). DFS itself has three common variations based on the position of the "root" node in the traversal order:

• In-Order Traversal: (Left, Root, Right) - For a BST, this visits nodes in ascending order.
• Pre-Order Traversal: (Root, Left, Right) - Useful for creating a copy of the tree.
• Post-Order Traversal: (Left, Right, Root) - Useful for deleting nodes from the tree.

There are two primary ways to represent a Graph: an Adjacency Matrix and an Adjacency List. The choice depends on the density of the graph (how many edges it has) and the operations you need to perform.

A Heap is a specialized tree-based data structure that satisfies the "heap property." It's typically used to implement Priority Queues, where you need to quickly find the minimum or maximum element. There are two types:

• Min-Heap: The value of each parent node is less than or equal to the value of its children. The root is the minimum element.
• Max-Heap: The value of each parent node is greater than or equal to the value of its children. The root is the maximum element.

Recursion is a powerful programming technique where a function calls itself to solve a problem. Every recursive function must have two parts:

• Base Case: A condition that stops the recursion and prevents an infinite loop.
• Recursive Step: The part of the function that calls itself, typically with a modified input that moves it closer to the base case.

It's a core concept in many Java interview questions involving trees and backtracking.

Both are part of complexity analysis (Big O Notation) and measure how an algorithm's resource usage scales with the input size `n`.

• Time Complexity measures how the runtime of an algorithm grows. An algorithm with O(n) time complexity will take roughly twice as long if the input size doubles.
• Space Complexity measures how the memory usage of an algorithm grows. This includes both the input space and any auxiliary space used by the algorithm.

The distinction is based on when the size and memory are allocated.

Problem: Given a collection of intervals, merge all overlapping intervals.

Solution: First, sort the intervals based on their start times. This is a critical step that allows us to handle overlaps linearly. Then, iterate through the sorted intervals, maintaining a list of merged intervals. If the current interval overlaps with the last one in our merged list, we update the end time of the last interval. Otherwise, we add the current interval as a new one. This approach uses one of the most fundamental sorting algorithms as a prerequisite.

Problem: Given the root of a Binary Search Tree and an integer `k`, find the `k`th smallest element in the tree.

Solution: The key property of a BST is that an In-Order Traversal (Left, Root, Right) visits the nodes in ascending order. We can perform an in-order traversal while keeping a count. The `k`th node we visit will be our answer. This can be done recursively or iteratively using a Stack.

Problem: Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`. You must solve this in O(n) time and without using the division operator.

Solution: This can be solved by making two passes over the array. In the first pass, create a `prefix` array where `prefix[i]` is the product of all numbers before index `i`. In the second pass (iterating backwards), calculate the `postfix` product. The final result for `answer[i]` is `prefix[i] * postfix_product`.

Problem: Given a reference of a node in a connected undirected Graph, return a deep copy (clone) of the graph.

Solution: This requires traversing the graph while keeping track of nodes that have already been copied to avoid infinite loops. A Hash Map is perfect for this, mapping original nodes to their copies. You can use either DFS (with recursion) or BFS (with a Queue) to traverse the original graph, creating copies of nodes and edges as you go.

Problem: Design a data structure for a Least Recently Used (LRU) cache. It should support `get` and `put` operations in O(1) time complexity.

Solution: This is a classic System Design question that combines two data structures. A Hash Map provides the O(1) lookup for `get`. A Doubly Linked List provides the O(1) additions and removals needed to manage the order of "recentness." The map stores keys and pointers to nodes in the linked list. When an item is accessed (`get` or `put`), it's moved to the front of the list. If the cache is full during a `put`, the item at the tail of the list is removed.

Problem: Given an integer array `nums` and an integer `k`, return the `k` most frequent elements.

Solution: First, count the frequency of each number using a Hash Map. Then, the problem becomes "find the top k elements" from our frequencies. An efficient way to do this is with a Min-Heap of size `k`. Iterate through the frequencies; if the heap has less than `k` elements, add the item. If the heap is full and the current item's frequency is greater than the smallest frequency in the heap (the root), remove the root and add the current item.

Problem: Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

Solution: A clean recursive solution is best. The base cases for the recursion are: if the current node is `null` or if it matches one of the two target nodes, return the current node. Then, recursively call the function on the left and right children. If the recursive calls on both left and right subtrees return non-null values, it means the current node is the LCA. Otherwise, if only one side returns a non-null value, propagate that value up the call stack.

Problem: Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s` can be segmented into a space-separated sequence of one or more dictionary words.

Solution: This is a classic Dynamic Programming problem. Create a 1D DP array, `dp`, of booleans, where `dp[i]` is `true` if the substring `s[0...i-1]` can be segmented. The base case is `dp[0] = true`. Iterate through the string from `i = 1` to `s.length`. For each `i`, iterate from `j = 0` to `i`. If `dp[j]` is `true` AND the substring `s[j...i-1]` is in the dictionary, then set `dp[i]` to `true` and break the inner loop.

Problem: Given an integer `n` and a list of edges, find the number of connected components in an undirected graph.

Solution: This is similar to the "Number of Islands" problem. Maintain a `visited` set to track nodes you've already seen. Iterate from node 0 to `n-1`. If a node has not been visited, it means we've found a new component. Increment a counter, and then start a traversal (either DFS or BFS) from this node to find and mark all nodes in its component as visited.

Problem: There is an integer array `nums` sorted in ascending order (with distinct values), which is possibly rotated at an unknown pivot. Given `nums` and a `target`, return the index of `target` if it is in `nums`, or -1 if it is not.

Solution: The array's partially sorted nature is a huge hint to use a modified Binary Search. In each step of the binary search, first determine which half of the current search space is sorted. Then, check if the `target` lies within that sorted half. If it does, adjust your `low` and `high` pointers to search within that half. If it doesn't, search the other, unsorted half. This is a very common variation of binary search in data structures interview questions.

Problem: Given `n` non-negative integers representing an elevation map, compute how much water it can trap after raining.

Optimal Solution (Two Pointers): This can be solved in O(n) time and O(1) space. Use two pointers, `left` and `right`, at the ends of the array, and maintain `left_max` and `right_max` heights seen so far. The amount of water trapped at any point is determined by the shorter of the two max heights. If `left_max < right_max`, the water level at the `left` pointer is limited by `left_max`. Calculate the trapped water (`left_max - height[left]`) and move `left` inward. Otherwise, do the same for the `right` side. This is a classic question in Amazon interview questions.

Problem: Design a data structure that supports adding numbers from a data stream and finding the median of all elements so far.

Solution: The optimal solution uses two Heaps: a Max-Heap to store the smaller half of the numbers and a Min-Heap to store the larger half. This clever use of heaps keeps the elements needed for the median at the top of the heaps, accessible in O(1) time. When adding a new number, place it in the appropriate heap and then "rebalance" the heaps to ensure their sizes differ by at most one.

Problem: You are given an array of `k` linked-lists, each sorted in ascending order. Merge all the linked-lists into one sorted linked-list.

Solution: While you could merge lists one by one, this is inefficient (O(N*k) where N is total nodes). The optimal solution uses a Min-Heap (Priority Queue). Insert the head of each of the `k` lists into the min-heap. Then, repeatedly extract the minimum node from the heap, add it to your result list, and insert the next node from the same list into the heap. This approach is O(N log k), which is much faster for a large `k`.

Problem: Given a 2D board of characters and a list of words, find all words on the board.

Solution: A naive approach of searching for each word individually is too slow. The optimal solution combines two techniques: build a Trie from the dictionary of words for efficient prefix lookups. Then, perform a single DFS (backtracking) traversal from every cell on the board. As you build a path in the DFS, check if the current path exists as a prefix in the Trie. If it does, continue the search. If it forms a complete word in the Trie, add it to your results. This is a common pattern in Python data structures problems.

Problem: You are given an array of integers `nums` and a sliding window of size `k`. Find the maximum value in the window as it moves from left to right.

Solution: The optimal O(n) solution uses a Deque (Double-Ended Queue). The deque will store indices of elements in the current window, in decreasing order of their values. Before adding a new element's index, remove all indices from the back of the deque that correspond to elements smaller than the new element. This ensures the index of the maximum element is always at the front. Also, remove indices from the front that are no longer in the window.

Problem: Given a string `s`, return the longest palindromic substring in `s`.

Optimal Solution (Expand From Center): While Dynamic Programming works, a more intuitive O(n²) time, O(1) space solution is "Expand From Center." Iterate through every character in the string, treating it as a potential center of a palindrome. From each center, expand outwards with two pointers to find the longest possible palindrome. Remember to handle both odd-length (center is one character) and even-length (center is between two characters) palindromes.

Problem: Design an algorithm to serialize a binary tree to a string and deserialize it back to the tree.

Solution: This problem tests your command of tree traversals. A **Pre-Order Traversal (DFS)** is ideal. To serialize, perform a pre-order traversal, appending each node's value to a string builder, using a special marker (like "N" or "#") for null nodes. To deserialize, split the string into a list. Use a global pointer or a Queue to build the tree recursively. The first element is the root. Its left child is built from the next part of the list, and its right child is built from the part after that.

Problem: On an infinite chessboard, what is the minimum number of moves for a knight to go from a starting square to a target square?

Solution: This is a shortest path problem on an unweighted, implicit Graph. This is a huge hint to use **Breadth-First Search (BFS)**. Start a BFS from the source square. In each step of the BFS, explore all 8 possible knight moves from the current square. Use a `visited` set to avoid cycles. The first time you reach the target square, you are guaranteed to have found the shortest path.

Problem: Given an array of integers `heights` representing the bar height of a histogram, find the area of the largest rectangle in the histogram.

Solution: This notoriously tricky problem has an elegant O(n) solution using a **monotonic stack**. The stack stores indices of bars in increasing order of height. When you encounter a bar that is shorter than the one at the top of the stack, you've found the right boundary for the bar(s) on the stack. Pop from the stack, calculate the area for the popped bar (its height * (current index - index of new stack top - 1)), and update your max area. It's a key problem in many DSA Courses.

Problem: Given an input string `s` and a pattern `p`, implement regular expression matching with support for `.` (matches any single character) and `*` (matches zero or more of the preceding element).

Solution: This is the pinnacle of hard recursion and **Dynamic Programming** problems. The solution involves building a 2D DP table, `dp[i][j]`, which is `true` if the first `i` characters of `s` match the first `j` characters of `p`. You build the table by considering several cases: if `p[j-1]` is a normal character, if it's a `.` (dot), or if it's a `*` (star). The `*` case is the most complex, as it can mean matching zero, one, or multiple characters.