DSA Interview Questions for Coding Interviews: Beginner to Pro

The questions below are organized progressively, starting with core fundamentals and moving toward pattern-heavy and design-oriented problems. Each section reflects what is typically asked across campus rounds, mid-level technical interviews, and senior engineering positions. 

Level 1: Basic DSA Interview Questions (Foundation Round)

This section focuses on the most commonly asked basic DSA interview questions in campus placements, internships, and screening rounds. These questions test your understanding of arrays, strings, linked lists, stacks, queues, and time complexity. Strong fundamentals here create the base required for solving more complex algorithmic challenges.

*henryharvin.ae

This section focuses on the most commonly asked basic DSA interview questions in campus placements, internships, and screening rounds. These questions test your understanding of arrays, strings, linked lists, stacks, queues, and time complexity. Strong fundamentals here create the base required for solving more complex algorithmic challenges.

1. How to reverse an array in-place?

Answer:

The optimal way to reverse an array in-place is by using the two-pointer technique.

We place one pointer at the beginning of the array and another at the end. Then we swap the elements at those positions and move both pointers toward the center. This continues until the pointers meet.

For example, if the array is [1, 2, 3, 4, 5]:

• Swap 1 and 5 → [5, 2, 3, 4, 1]
• Swap 2 and 4 → [5, 4, 3, 2, 1]

The middle element remains unchanged.

Time complexity is O(n) since each element is processed once.
Space complexity is O(1) because no extra array is used.

2. How to check if a string is a palindrome?

Answer:

To check whether a string is a palindrome, we compare characters from both ends using two pointers.

One pointer starts at the beginning and the other at the end. If the characters match, both pointers move inward. If any mismatch occurs, the string is not a palindrome.

For example:
Input: “madam” → Output: True
Input: “hello” → Output: False

If the problem says to ignore case or special characters, we first normalize the string and then apply the same logic.

Time complexity is O(n) and space complexity is O(1).

3. How to find the largest element in an array?

Answer:

We initialize a variable max with the first element of the array. Then we traverse the array and compare each element with max. If a larger value is found, we update max.

For example:
Input: [3, 8, 2, 10, 6]
We start with 3, update to 8, then finally update to 10.
Output: 10

Time complexity is O(n) and space complexity is O(1).

4. What is the difference between array and linked list?

Answer:

An array stores elements in contiguous memory locations, which allows direct access using an index in O(1) time. However, insertion and deletion operations can be costly because shifting elements may be required.

A linked list stores elements in non-contiguous memory locations where each node contains data and a pointer to the next node. Insertion and deletion are efficient if the reference node is known, typically O(1), but accessing elements requires traversal, which takes O(n).

Arrays have better cache performance, while linked lists are more flexible in dynamic memory usage.

5. How does binary search work?

Answer:

Binary search works on a sorted array.

We maintain two pointers: low and high. We calculate the middle index and compare the middle element with the target.

• If equal, return the index.
• If the target is smaller, search in the left half.
• If larger, search in the right half.

For example, searching 7 in [1, 3, 5, 7, 9]:

• Mid = 5 → target is greater
• Move right
• Mid = 7 → found

Time complexity is O(log n).

6. What is time complexity and explain Big O notation?

Answer:

Time complexity measures how the running time of an algorithm grows as the input size increases.

Big O notation represents the upper bound of the time required.

Examples:

• O(1) → constant time
• O(n) → linear time
• O(log n) → logarithmic time
• O(n²) → quadratic time

In interviews, we usually discuss worst-case complexity.

7. How to detect duplicate elements in an array?

Answer:

One efficient way is to use a HashSet.

We traverse the array and insert each element into the set. If we encounter an element that already exists in the set, it is a duplicate.

For example:
Input: [1, 3, 4, 2, 3]
Since 3 appears twice, it is a duplicate.

Time complexity is O(n) and space complexity is O(n).

If extra space is not allowed, we can sort the array and check adjacent elements.

8. What is a stack and where is it used?

Answer:

A stack is a linear data structure that follows the LIFO principle — Last In, First Out.

Main operations:

• Push
• Pop
• Peek

Common applications:

• Function call stack in recursion
• Expression evaluation
• Parenthesis validation
• Undo/redo functionality

All operations typically take O(1) time.

9. What is a queue and where is it used?

Answer:

A queue is a linear data structure that follows the FIFO principle: First In, First Out.

Main operations:

• Enqueue
• Dequeue

Common applications:

• CPU scheduling
• Breadth-first search
• Handling requests in systems

Operations generally take O(1) time.

10. How to detect a cycle in a linked list?

Answer:

The most efficient way is using Floyd’s Cycle Detection Algorithm, also called the Tortoise and Hare approach.

We use two pointers:

• Slow pointer moves one step at a time
• Fast pointer moves two steps at a time

If the linked list contains a cycle, both pointers will eventually meet. If the fast pointer reaches null, then no cycle exists.

Time complexity is O(n) and space complexity is O(1).

Level 2: Intermediate DSA Interview Questions

*henryharvin.ae

At this level, interviewers expect pattern recognition and optimization thinking. These questions cover hashing, sliding window techniques, heaps, recursion, and linked list manipulation. You are not just expected to solve the problem but to explain alternative approaches clearly.

1. How to solve the Two Sum problem?

Answer:

The optimized approach is to use a HashMap.

We iterate through the array and for each element x, we check whether target – x already exists in the map. If it exists, we return the indices. Otherwise, we store the current element and its index in the map.

Example:
Input: [2, 7, 11, 15], target = 9
When processing 7, 9 – 7 = 2 already exists in the map, so we return [0, 1].

Time complexity: O(n)
Space complexity: O(n)

2. How to find the first non-repeating character in a string?

Answer:

We use a frequency map.

First, traverse the string and count the frequency of each character. Then traverse the string again and return the first character whose frequency is 1.

Example:
Input: “swiss”
Frequencies: s=3, w=1, i=1
Output: w

Time complexity: O(n)

3. How to validate parentheses in a string?

Answer:

We use a stack.

Whenever we encounter an opening bracket, we push it onto the stack. For a closing bracket, we check whether the stack is empty or if the top element does not match the corresponding opening bracket. If either condition fails, the string is invalid.

At the end, the stack must be empty for the string to be valid.

Example:
Input: “({[]})” → Valid
Input: “(]” → Invalid

Time complexity: O(n)

4. How to merge two sorted arrays?

Answer:

We use the two-pointer technique.

One pointer starts at the beginning of each array. We compare the elements at both pointers and insert the smaller one into the result array. Then we move that pointer forward. This continues until all elements are merged.

Time complexity: O(n + m)

If in-place merging is required and space is available in the first array, we can fill from the end to avoid overwriting elements.

5. How to find the middle element of a linked list?

Answer:

We use the slow and fast pointer approach.

The slow pointer moves one step at a time, and the fast pointer moves two steps at a time. When the fast pointer reaches the end of the list, the slow pointer will be at the middle.

Time complexity: O(n)
Space complexity: O(1)

6. How to find the kth largest element in an array?

Answer:

An efficient approach is to use a min heap of size k.

We insert elements into the heap. If the heap size exceeds k, we remove the smallest element. After processing all elements, the top of the heap represents the kth largest element.

Time complexity: O(n log k)

Alternatively, QuickSelect can be used with an average time complexity of O(n).

7. How to check if two strings are anagrams?

Answer:

One approach is to sort both strings and compare them.

A more efficient approach is to use a frequency array or HashMap. We increment the count for characters in the first string and decrement for the second string. If all counts are zero at the end, the strings are anagrams.

Example:
“listen” and “silent” → True

Time complexity: O(n)

8. How to find the maximum subarray sum?

Answer:

We use Kadane’s Algorithm.

We maintain two variables: current_sum and max_sum. For each element, current_sum becomes the maximum of the current element or current_sum + element. We update max_sum accordingly.

Example:
Input: [-2,1,-3,4,-1,2,1,-5,4]
Output: 6 (subarray [4,-1,2,1])

Time complexity: O(n)

9. How to reverse a linked list?

Answer:

We use three pointers: previous, current, and next.

Initialize previous as null and current as head. For each node:

• Store the next node.
• Reverse the current node’s pointer to previous.
• Move previous and current one step forward.

At the end, previous becomes the new head of the reversed list.

Time complexity: O(n)

10. How to find the height of a binary tree?

Answer:

We use recursion.

For each node, the height is calculated as:

1 + max(height of left subtree, height of right subtree)

The base case is when the node is null, in which case we return 0.

Time complexity: O(n)

Level 3: Senior-Level DSA Interview Questions (Advanced)

Senior-level interviews move beyond direct coding and focus on scalable design, graph algorithms, dynamic programming, and system-integrated problem solving. Questions here test depth, optimization strategy, and real-world application of data structures. Clarity of thought and ability to justify design decisions become critical at this stage.

1. How would you design and implement an LRU Cache?

Answer:

To implement an LRU (Least Recently Used) cache with O(1) operations for both get and put, we combine two data structures:

• A HashMap for O(1) access to nodes.
• A Doubly Linked List to maintain usage order.

When a key is accessed or updated, we move it to the front of the linked list.
When capacity exceeds the limit, we remove the node from the tail (least recently used) and delete it from the HashMap.

Time Complexity:

• Get → O(1)
• Put → O(1)

This design balances fast lookup and efficient eviction.

2. How would you find the kth largest element in a stream of data?

Answer:

Since data is streaming, we cannot sort repeatedly.

We maintain a min-heap of size k.

• Insert each incoming element into the heap.
• If heap size exceeds k, remove the smallest element.
• The top of the heap will always represent the kth largest element.

Time per insertion: O(log k)
Space complexity: O(k)

This approach scales well for large streams.

3. How would you detect a cycle in a directed graph?

Answer:

We use DFS with a recursion stack.

During DFS:

• Mark node as visited.
• Add it to the recursion stack.
• If during traversal we encounter a node already in the recursion stack, a cycle exists.

Alternatively, we can use Kahn’s Algorithm (Topological Sorting).
If the number of processed nodes is less than the total number of nodes, the graph contains a cycle.

Time Complexity: O(V + E)

4. How would you find the shortest path in a weighted graph?

Answer:

If weights are non-negative, we use Dijkstra’s Algorithm.

• Initialize distances as infinity.
• Use a min-heap to always process the node with smallest distance.
• Update neighbors if a shorter path is found.

Time complexity using priority queue: O((V + E) log V)

If negative weights exist, we use Bellman-Ford.

5. How would you solve the Longest Increasing Subsequence problem?

Answer:

The brute force solution uses dynamic programming with O(n²) time.

For optimization, we use a binary search-based approach with a temporary array that tracks potential sequence endings.

For each element:

• Use binary search to place it in correct position in the helper array.

Optimized Time Complexity: O(n log n)

This approach is expected in senior-level interviews.

6. How would you implement a Trie (Prefix Tree)?

Answer:

A Trie is used for efficient prefix-based searching.

Each node contains:

• An array/map of children.
• A boolean flag to mark end of word.

For insertion:

• Traverse character by character.
• Create nodes if not present.
• Mark end node.

Time complexity per operation: O(L), where L is word length.

Tries are commonly used in autocomplete systems and dictionary problems.

7. How would you handle Union-Find (Disjoint Set)?

Answer:

Union-Find is used to detect connected components.

We maintain:

• Parent array.
• Rank or size array.

Operations:

• Find with path compression.
• Union by rank.

Amortized time complexity per operation: nearly O(1).

Commonly used in Kruskal’s algorithm for Minimum Spanning Tree.

8. How would you solve the Maximum Subarray Sum in 2D matrix?

Answer:

We extend Kadane’s algorithm to 2D.

• Fix left and right column boundaries.
• Compress rows into a temporary 1D array.
• Apply Kadane’s algorithm on the compressed array.

Time Complexity: O(n³)

This problem checks optimization thinking and pattern extension.

9. How would you design a rate limiter?

Answer:

A common approach is the Sliding Window or Token Bucket algorithm.

We track request timestamps per user.
If the number of requests within a defined time window exceeds the limit, reject the request.

In distributed systems, Redis or centralized counters are used.

This tests data structure + system awareness.

10. How would you serialize and deserialize a binary tree?

Answer:

We use preorder traversal and represent null nodes explicitly.

For serialization:

• Traverse tree in preorder.
• Append node values to a string.
• Use a marker like “#” for null.

For deserialization:

• Reconstruct tree using the same traversal order.

Time Complexity: O(n)

This question tests tree understanding and recursive design.

Clearing DSA interview questions is one thing. Building a career that actually grows, that’s different. If you’re already putting in hours solving problems, it makes sense to channel that effort into something bigger. Jaro Education provides Online Analytics and Data Science Courses via top ranked university, which are designed exactly for that shift. 

With our vision of #CareerGrowthSimplified, the idea is simple: to help professionals upskill with a strong, industry-relevant certificate that makes your profile harder to ignore.

Why consider Jaro?

• The curriculum feels current. Not textbook-heavy. Built around what hiring managers are actually asking for.
  
• Flexible format, so you don’t quit your job just to learn.
  
• Strong academic partnerships and industry recognition. That credibility matters more than people admit.
  
• Career support that goes beyond “good luck after the course.”

If you’re already preparing for interviews, don’t stop at clearing one. Build leverage. Add depth. And move upward.

DSA interview questions are the gateway, not the destination. Strong fundamentals open doors, but continuous upskilling keeps them open. Prepare smart. Practice patterns. Think clearly. And while you’re at it, invest in skills that compound over time. Because in tech, growth isn’t optional, it’s survival.