Data Structures and Algorithms Interview Questions

What should I focus on when preparing?

Which topics should I start with?

Start with arrays and strings. They appeared in 128 of 374 interviews, more than any other topic. Hash maps and sets came next, followed by basics and complexity.

Use these checks to find what you need to review:

• Can you solve array and string problems using scans, two pointers, sliding windows, prefix sums, and frequency counts?
• Can you check edge cases in your array and string code?
• Can you explain the time and space your code uses with Big-O notation?

For each approach, check whether you can write the code as well as explain it. Knowing the name of a technique is not the same as completing the task.

Which coding tasks should I check first?

A coding task appeared in 209 of 374 interviews. Two Sum was the most asked question, appearing in 26 of 374 interviews.

Check the exact requirement, not just the problem name:

• Does your Two Sum function return the matching indices, and can you explain its time complexity?
• Can your palindrome checker ignore case and characters that are not letters or numbers?
• Can you reverse a string in place without allocating another array?
• Can you generate Fibonacci terms with a loop or recursion, adding the previous two terms each time?

Reviewed Two Sum answers missed a working function that returned the matching indices. Reviewed Fibonacci answers missed code that generated the terms as required. Check your implementation against those requirements.

Can I explain how a hash map works?

Reviewed Java HashMap answers missed a specific step: how a key’s hash determines its bucket index before keys within that bucket are compared.

Can you explain that sequence in plain words? Also check whether you can explain collisions, resizing, and key equality. For collection comparisons, can you describe how arrays and linked lists differ in memory layout and operations?

What should I check beyond arrays and maps?

Use these tasks to check other topics:

• Implement binary search, explain when it applies, and give its time complexity.
• Compare merge sort, quicksort, and heap sort, including their time complexities.
• Explain how you represent a tree or graph and how you visit its nodes.
• Explain how a stack supports bracket checking or expression evaluation.
• Describe an algorithm choice for a cache, rate limiter, or scheduling problem.

Who gets asked Data Structures and Algorithms

The 20 most asked Data Structures and Algorithms questions

Counted by interview, not by mention: a question asked twice in one conversation counts once.

1. Write a Two Sum function returning the matching indices, and explain its time complexity.

   Asked in 26 of 374 interviews · last asked Oct 23 · Write code · Junior

   Show answer

   Use a hash map to return the indices of two numbers whose sum equals the target. For each number, look for its complement, then store the number and its index. One pass takes O(n) time on average because hash-map operations take O(1) on average. Extra space is O(n).

   • The complement is the target minus the current number.
   • Check before storing so the same index is not used twice.
   • Duplicate values work when they occur at different indices.
   • Return one matching pair, or an empty list if no pair exists.

   PythonCopy

   def two_sum(nums, target):
       seen = {}
       for i, value in enumerate(nums):
           complement = target - value
           if complement in seen:
               return [seen[complement], i]
           seen[value] = i
       return []

   What the interviewer checks: The interviewer checks whether you can write correct code and explain how a hash map avoids checking every pair.

   Common mistake (in 7 of 10 reviewed answers): Many answers forget that the function must return two distinct indices, not the matching values.

   Other ways it was asked

   • “Write a function that solves the Two Sum problem.”
   • “What is the time complexity of a solution to the Two Sum problem?”
   • “What is the time complexity of your Two Sum solution?”

2. Write a palindrome checker, and explain how to ignore case and non-alphanumeric characters.

   Asked in 13 of 374 interviews · last asked Oct 22 · Write code · Junior

   Show answer

   Keep only letters and numbers, make case differences irrelevant, and compare the result with its reverse. In Python, use casefold() to ignore case and isalnum() to filter characters. If the cleaned string equals its reverse, it is a palindrome.

   • This solution takes O(n) time and O(n) extra space.
   • Empty strings and strings with no letters or numbers count as palindromes.
   • Python's isalnum() accepts Unicode letters and numbers, not just ASCII.

   PythonCopy

   def is_palindrome(text: str) -> bool:
       cleaned = ''.join(char for char in text.casefold() if char.isalnum())
       return cleaned == cleaned[::-1]
   
   assert is_palindrome('A man, a plan, a canal: Panama!')
   assert not is_palindrome('hello')
   assert is_palindrome('!!!')

   What the interviewer checks: The interviewer is checking whether you can compare characters correctly, clean the input, and explain edge cases and cost.

   Other ways it was asked

   • “How would you check whether a string is a palindrome?”
   • “How can you identify whether a word is a palindrome?”
   • “Can you write code to determine whether a string is a palindrome?”

3. Write code to reverse a string in place without allocating another array.

   Asked in 9 of 374 interviews · last asked Oct 12 · Write code · Junior

   Show answer

   Swap the first and last characters, then move inward until the pointers meet. Java strings are immutable, so true in-place reversal needs an existing mutable array, such as char[]. This code reverses that array without allocating another array.

   • Time is O(n), and extra space is O(1).
   • Empty arrays and single-character arrays stay unchanged.
   • Java char values are UTF-16 code units; reversing them can break surrogate pairs.

   CodeCopy

   class Solution {
       static void reverse(char[] chars) {
           int left = 0, right = chars.length - 1;
           while (left < right) {
               char temp = chars[left];
               chars[left++] = chars[right];
               chars[right--] = temp;
           }
       }
   }

   What the interviewer checks: The interviewer checks whether you can use two pointers, avoid extra storage, and recognize that Java strings are immutable.

   Other ways it was asked

   • “Write code to reverse a string.”
   • “Write Java code to reverse a string.”
   • “How would you write code to reverse a string?”

4. Write a program to generate the Fibonacci series.

   Asked in 8 of 374 interviews · last asked Oct 14 · Write code · Junior

   Show answer

   I generate the first n Fibonacci numbers, starting with 0 and 1. Each later number is the sum of the previous two. This Python solution uses a loop and returns the numbers in a list.

   • Update both values together so the calculation uses their old values.
   • For n = 0, return an empty list; reject negative n.
   • Time is O(n), and the returned list uses O(n) space, assuming constant-cost integer arithmetic.

   PythonCopy

   def fibonacci(n):
       if n < 0:
           raise ValueError("n must be non-negative")
       result = []
       a, b = 0, 1
       for _ in range(n):
           result.append(a)
           a, b = b, a + b
       return result
   print(fibonacci(7))  # [0, 1, 1, 2, 3, 5, 8]

   What the interviewer checks: The interviewer checks whether you can use a loop, update values correctly, and handle small inputs.

   Common mistake (in 5 of 5 reviewed answers): Many answers forget that each new term must be computed as the sum of the previous two.

   Other ways it was asked

   • “Write a Python program to display the Fibonacci series.”
   • “Write a Python program for the Fibonacci series.”
   • “Can you write Python code to generate the Fibonacci sequence?”

5. Write code to find the largest number in an array.

   Asked in 6 of 374 interviews · last asked Oct 24 · Write code · Junior

   Show answer

   Scan the array once, keeping the largest value seen so far. Start with the first element so negative numbers work correctly. For an empty array, this function raises an error because there is no largest value.

   • One scan takes O(n) time and O(1) extra space.
   • Start with the first element, not zero.
   • Handle an empty array explicitly.

   PythonCopy

   def find_largest(numbers):
       if not numbers:
           raise ValueError("Array must not be empty")
       largest = numbers[0]
       for number in numbers:
           if number > largest:
               largest = number
       return largest

   What the interviewer checks: The interviewer checks whether you can scan an array, track a maximum, and handle edge cases.

   Other ways it was asked

   • “How would you find the maximum element in an array?”
   • “How would you find the maximum element in an array and count how many times it appears?”
   • “How would you find the largest number in a Java array?”

6. What is the difference between an array and a linked list?

   Asked in 6 of 374 interviews · last asked Sep 30 · Concept · Junior

   Show answer

   An array stores elements in one continuous memory block. A linked list stores nodes connected by links, which may be scattered in memory. Array access by index is O(1); linked list access by index is O(n). Python's built-in list is a dynamic array, not a linked list.

   • Array insertion or deletion can take O(n) because elements may need to shift.
   • Linked list insertion or deletion is O(1) with the required node and predecessor references; finding them takes O(n).
   • Linked lists need extra memory for links; arrays usually make better use of CPU caches.

   What the interviewer checks: The interviewer checks whether you understand memory layout, access speed, update costs, and language-specific naming.

   Other ways it was asked

   • “What is the difference between an array and a list?”
   • “What is the difference between a list and an array in Python?”

7. What are the differences between ArrayList and LinkedList in Java?

   Asked in 6 of 374 interviews · last asked Oct 16 · Concept · Junior

   Show answer

   ArrayList uses a resizable array, while LinkedList uses a doubly linked list. Both implement Java's List interface. ArrayList provides O(1) access by index, while LinkedList takes O(n). ArrayList shifts elements for middle insertions or removals; LinkedList changes links in O(1), but finding the position takes O(n).

   • ArrayList appends take O(1) amortized time; resizing can take O(n).
   • LinkedList adds or removes elements at either end in O(1) and also implements Deque.
   • An already-positioned LinkedList ListIterator can insert or remove in O(1).
   • ArrayList usually uses less memory and is faster to iterate because its storage is more compact.

   What the interviewer checks: The interviewer checks whether you can connect each internal structure to its performance and choose the right list.

   Other ways it was asked

   • “What is the difference between ArrayList and LinkedList?”
   • “What is the difference between Java's ArrayList and LinkedList?”
   • “What is the difference between the List interface and LinkedList in Java?”

8. How does HashMap work internally in Java?

   Asked in 6 of 374 interviews · last asked Oct 16 · Concept · Senior

   Show answer

   Java's HashMap stores key-value pairs in an array of buckets. It mixes the key's hashCode() and uses that hash to choose a bucket. Within the bucket, it checks hashes and compares keys with equals(). Collisions use linked lists; in Java 8 and later, crowded buckets can become red-black trees.

   • The bucket index is (capacity - 1) & mixedHash; capacity is a power of two.
   • Tree conversion requires at least 64 buckets; smaller tables resize instead.
   • The default load factor is 0.75; exceeding the size threshold normally doubles capacity and redistributes entries.
   • get() and put() take O(1) time on average when hashes spread keys well.

   What the interviewer checks: The interviewer checks whether you understand bucket selection, key comparison, collisions, and resizing.

   Common mistake (in 5 of 6 reviewed answers): Many answers forget that the hash selects a bucket before keys inside that bucket are compared.

   Other ways it was asked

   • “How does Java's HashMap work?”
   • “How does HashMap work in Java?”
   • “How does HashMap handle internal operations in modern Java?”

9. What is a hash map, and how does it store and retrieve values by key?

   Asked in 6 of 374 interviews · last asked Sep 18 · Concept · Junior

   Show answer

   A hash map stores key-value pairs. It uses a hash function to turn each key into an array position. To retrieve a value, it hashes the key again and compares keys to find the matching entry, handling cases where different keys map to the same position.

   • Lookup, insertion, and deletion take O(1) time on average with good hashing.
   • Collisions are handled by storing multiple entries together or searching other array positions.
   • Equal keys must have equal hash values, but different keys may share a hash value.
   • Worst-case operations can take O(n) time, depending on the implementation.

   What the interviewer checks: The interviewer checks whether you understand hashing, key comparison, collisions, and average lookup speed.

   Other ways it was asked

   • “What is a HashMap?”
   • “What is a HashMap in Java?”
   • “How does a hash table use a unique identifier to look up a record?”

10. Compare merge sort, quicksort, and heap sort, including their time complexities.

    Asked in 6 of 374 interviews · last asked Oct 9 · Concept · Junior

    Show answer

    Standard merge sort takes O(n log n) time in the best, average, and worst cases. Quicksort takes O(n log n) in the best and average cases, but O(n²) in the worst case. Heap sort takes O(n log n) on average and in the worst case.

    • Merge sort can preserve equal elements' order, making it stable; array implementations usually need O(n) extra space.
    • Typical recursive quicksort uses O(log n) stack space on average, but O(n) in the worst case.
    • Quicksort is usually not stable; randomized pivots reduce the risk of poor splits.
    • Heap sort is not stable, uses O(1) extra space, and guarantees O(n log n) worst-case time.

    What the interviewer checks: The interviewer checks whether you can compare time guarantees, memory use, and stability when choosing a sorting algorithm.

    Other ways it was asked

    • “What is the time complexity of merge sort and quicksort?”
    • “What are the time complexities of bubble sort and merge sort?”
    • “What is the time complexity of merge sort?”

11. Implement binary search, explain when it applies, and give its time complexity.

    Asked in 6 of 374 interviews · last asked Sep 14 · Concept · Junior

    Show answer

    Binary search finds a target in a sorted array by checking the middle and repeatedly halving the search range. It needs sorted data and constant-time access by index for O(log n) worst-case time. An iterative implementation uses O(1) extra space.

    • The comparison order must match the array's sort order.
    • After each comparison, discard the half that cannot contain the target.
    • Return -1 if the target is missing, including for an empty array.
    • With duplicates, this version returns any matching index, not necessarily the first.

    PythonCopy

    def binary_search(arr, target):
        # arr must be sorted in ascending order.
        low, high = 0, len(arr) - 1
        while low <= high:
            mid = low + (high - low) // 2
            if arr[mid] == target: return mid
            if arr[mid] < target:
                low = mid + 1
            else: high = mid - 1
        return -1

    What the interviewer checks: The interviewer checks whether you handle search boundaries correctly and explain the requirements and cost of binary search.

    Other ways it was asked

    • “What is the time complexity of binary search?”
    • “What is binary search, and when can it be used?”
    • “What is the binary search algorithm, and when can it be used?”

12. What is a linked list?

    Asked in 5 of 374 interviews · last asked Sep 13 · Concept · Junior

    Show answer

    A linked list is a sequence of nodes, where each node stores data and a link to the next node. The nodes do not need to sit next to each other in memory. You start at the head and follow links to reach other nodes. A doubly linked list also links each node to the previous node.

    • Access by position takes O(n) time because you must follow links.
    • Insertion or deletion takes O(1) once you have the needed node references; finding them can take O(n).
    • Links use extra memory compared with an array.
    • An empty list has no data nodes; a non-circular list usually ends with a null link.

    CodeCopy

    head → [10] → [20] → [30] → null

    What the interviewer checks: The interviewer checks whether you understand nodes, links, traversal, and the basic trade-offs compared with arrays.

    Other ways it was asked

    • “Can you explain a linked list?”
    • “What is a linked list, and how does it work?”
    • “How does a linked list work?”

13. How do BFS and DFS differ, and when would you choose BFS?

    Asked in 5 of 374 interviews · last asked Oct 7 · Concept · Junior

    Show answer

    BFS explores nodes level by level using a queue. DFS follows one path as far as possible before backtracking, using a stack or recursion. Choose BFS to find a shortest path in an unweighted graph, find the nearest matching node, or process nodes level by level.

    • BFS finds paths with the fewest edges; DFS does not guarantee this.
    • Both take O(V + E) time with adjacency lists, where V counts vertices and E counts edges.
    • Track visited nodes in graphs to avoid revisiting nodes and looping through cycles.
    • BFS can hold many nodes on wide levels; recursive DFS risks stack overflow on deep paths.

    What the interviewer checks: The interviewer checks whether you understand traversal order, data structures, and why BFS suits unweighted shortest paths.

    Other ways it was asked

    • “What is the difference between BFS and DFS?”
    • “How are DFS and BFS different?”
    • “What is the difference between depth-first search (DFS) and breadth-first search (BFS)?”

14. What is the difference between mutable and immutable data types, and where would you use them?

    Asked in 4 of 374 interviews · last asked Oct 22 · Concept · Junior

    Show answer

    Mutable objects can change after they are created. Immutable objects cannot; a different value requires a different object. Use mutable types for data you update often, such as a growing list. Use immutable types for values that should stay fixed or be shared without changes, such as strings in Python.

    • Changing a mutable object can affect every variable that refers to it.
    • Reassigning a variable is not the same as changing its object.
    • In Python, lists are mutable and strings are immutable.
    • Immutable containers can still hold mutable objects; a Python tuple can contain a list.

    PythonCopy

    items = [1, 2]
    shared = items
    items.append(3)
    print(shared)  # [1, 2, 3]: the same list changed
    
    name = "Sam"
    original = name
    name = name + "!"
    print(original)  # Sam: the original string did not change

    What the interviewer checks: The interviewer checks whether you understand object changes, shared references, and when to use each type.

    Other ways it was asked

    • “Give one example of a mutable data type and one example of an immutable data type.”
    • “Give an example of a mutable and an immutable data type, and explain how you can tell the difference.”
    • “What is the basic difference between a mutable data type and an immutable data type?”

15. What is the difference between an array and an ArrayList?

    Asked in 4 of 374 interviews · last asked Oct 22 · Concept · Junior

    Show answer

    In Java, an array has a fixed length, while an ArrayList can grow or shrink as elements are added or removed. Arrays can hold primitive values or objects, but ArrayList holds only objects, using wrapper types for primitives. List is an interface; ArrayList is one implementation of it.

    • Both provide constant-time access by index.
    • Arrays use length; ArrayList uses size() to report the number of elements.
    • ArrayList uses an internal array and may copy elements when it needs more capacity.
    • Inserting or removing elements in the middle of an ArrayList requires shifting elements.

    What the interviewer checks: The interviewer checks whether you understand size limits, supported types, and the difference between an interface and its implementation.

    Other ways it was asked

    • “What is the difference between ArrayList and List in Java?”
    • “How is an array different from an ArrayList?”

16. In Java, how does an ArrayList grow internally when it runs out of capacity, and what happens to existing elements during that growth?

    Asked in 4 of 374 interviews · last asked Oct 22 · Concept · Mid-level

    Show answer

    When an ArrayList fills up, it allocates a larger backing array and copies existing element references into it. In current OpenJDK, growth is usually about 1.5 times the old capacity. Growth does not clone objects or change their order or indices. A no-argument ArrayList starts empty and normally allocates capacity 10 on its first add.

    • The exact growth policy depends on the implementation and version; Java does not guarantee a growth factor.
    • A growth operation takes O(n) time because it copies existing references.
    • Appending takes amortized O(1) time across many additions.
    • Capacity is the backing array length; size is the number of stored elements.

    What the interviewer checks: The interviewer checks whether you understand array resizing, reference copying, and the cost of appending.

    Other ways it was asked

    • “In Java, when an ArrayList grows past capacity, what happens to its backing storage and what does that imply for existing element references and indices?”
    • “In Java, what happens internally when you add an element to an ArrayList beyond its current capacity? How is the backing array resized, and how are existing elements moved?”
    • “What is the default capacity of a Java ArrayList, and how does it grow when you add more elements?”

17. How does Java HashMap handle collisions, and how did Java 8 change crowded buckets?

    Asked in 4 of 374 interviews · last asked Oct 17 · Concept · Mid-level

    Show answer

    HashMap stores colliding entries in the same bucket and uses hash values and equals() to find keys. Buckets normally use linked lists. Java 8 added red-black trees for crowded buckets, with a treeification threshold of 8 and a minimum table capacity of 64. Below that capacity, HashMap grows the table instead.

    • In OpenJDK's put path, adding a ninth bucket entry can trigger treeification.
    • Tree lookup is usually O(log n), but same-hash, non-comparable keys can still require O(n).
    • Equal keys replace values; different keys can share a bucket.

    What the interviewer checks: The interviewer checks whether you understand collisions, key equality, and when HashMap uses trees instead of lists.

    Other ways it was asked

    • “How did HashMap improve collision handling after Java 8?”
    • “What changed in HashMap collision handling after Java 8?”
    • “In Java, explain how HashMap handles collisions internally, and what changes when a bucket gets treeified.”

18. What is recursion?

    Asked in 4 of 374 interviews · last asked Oct 6 · Concept · Junior

    Show answer

    Recursion is when a function calls itself to solve a smaller version of the same problem. A base case stops the calls. Each call must move toward that base case, and its result returns to the previous call.

    • The base case handles a simple input without another recursive call.
    • The recursive case reduces the problem and calls the function again.
    • Recursive calls usually use stack space; too many calls can cause a stack overflow.

    PythonCopy

    def factorial(n):
        if n < 0:
            raise ValueError("n must be nonnegative")
        if n == 0:
            return 1
        return n * factorial(n - 1)
    
    print(factorial(4))  # 24

    What the interviewer checks: The interviewer checks whether you understand self-calls, base cases, and why recursion stops.

    Other ways it was asked

    • “Can you explain recursion?”
    • “Can you explain to me how recursion works?”
    • “What is recursion, and how does it work?”

19. Design and implement an LRU cache with O(1) get and put operations.

    Asked in 4 of 374 interviews · last asked Sep 10 · Write code · Mid-level

    Show answer

    I use a hash map and a doubly linked list for average O(1) get and put operations. Each successful get or put moves the key to the most recently used end. When capacity is exceeded, I remove the least recently used key. Python's OrderedDict provides this structure.

    • Hash map operations take O(1) time on average; cache space is O(capacity).
    • A missing key returns -1 and does not change the cache.
    • Updating an existing key changes its value and recency without increasing the cache size.
    • A cache with zero capacity stores no entries.

    PythonCopy

    from collections import OrderedDict
    class LRUCache:
        def __init__(self, capacity):
            self.capacity, self.items = max(0, capacity), OrderedDict()
        def get(self, key):
            if key not in self.items: return -1
            self.items.move_to_end(key); return self.items[key]
        def put(self, key, value):
            self.items[key] = value; self.items.move_to_end(key)
            if len(self.items) > self.capacity: self.items.popitem(last=False)

    What the interviewer checks: The interviewer checks whether you can combine fast lookup with recency tracking and handle updates and eviction correctly.

    Other ways it was asked

    • “How would you design and implement an LRU cache?”
    • “Design and implement an LRU cache with get(key) and put(key, value) operations.”
    • “Design an LRU cache with get(key) and put(key, value) operations that run in O(1) time.”

20. Write a Python program to check whether a number is prime.

    Asked in 3 of 374 interviews · last asked Oct 17 · Write code · Junior

    Show answer

    Check whether the integer has a divisor between 2 and its square root. Numbers below 2 are not prime. If no divisor is found, the number is prime.

    • Negative numbers, 0, and 1 are not prime.
    • 2 is prime; all other even numbers are not.
    • Check through the square root, including it, to catch perfect squares.
    • Trial division takes O(√n) time and O(1) extra space.

    PythonCopy

    from math import isqrt
    def is_prime(n):
        if n < 2:
            return False
        if n % 2 == 0: return n == 2
        for divisor in range(3, isqrt(n) + 1, 2):
            if n % divisor == 0:
                return False
        return True
    print(is_prime(int(input())))

    What the interviewer checks: The interviewer is checking correct edge cases and whether you avoid testing divisors beyond the square root.

    Other ways it was asked

    • “Write Python code to determine whether a number is prime.”

Live coding round next? Coding mode in the MeetAssist desktop app solves the problem on your screen, with your phone as the remote.

Related interview questions

• Software Engineer interview questions
• AI Engineer interview questions
• QA Engineer interview questions
• Data Scientist interview questions
• Data Engineer interview questions
• OOP and Design Patterns interview questions
• System Design interview questions
• Microservices interview questions
• REST API interview questions
• Kafka and Message Queues interview questions
• Caching and Redis interview questions
• Operating Systems interview questions
• Computer Networks interview questions
• Git interview questions

How this list is made

Every question here was asked by a real interviewer in a real job interview that a candidate ran MeetAssist in. After the call, the interviewer's questions are pulled from the transcript. Practice sessions, tests, exams and anything that was not a job interview are dropped.

Questions are rewritten so they make sense on their own: names of people, employers and clients are removed, and speech-to-text mistakes are fixed. Small talk, logistics and questions about one candidate's own résumé are left out. Rephrasings of the same question are merged, and the count is the number of different interviews it came up in.

The interviews come from candidates who use MeetAssist, so they lean towards software, data and AI roles: the shares describe these interviews, not every Data Structures and Algorithms interview. Answers to the most asked questions are written and checked by an editor; a "common mistake" is shown only when reviews of real answers in these interviews show it, with the count.

374 interviews, 269 candidates, Sep 2025 to Oct 2026. Updated every month with new interviews.