50 Important Data Structures Interview Questions for SDE Freshers

Top 50 Data structures interview questions for freshers

The tech hiring landscape has transformed dramatically in 2026. Companies are now conducting AI-assisted technical interviews, and according to recent LinkedIn data, over 73% of tech recruiters consider data structures knowledge as the primary filter for fresher SDE roles.

Moreover, with Anthropic’s Claude and other AI tools now assisting developers in writing code, interviewers have shifted their focus—they’re no longer just testing if you can code, but whether you truly understand the underlying structures that make efficient software possible.

Here’s the reality: You could have built ten projects, contributed to open-source, or even completed multiple internships. However, if you stumble when asked to explain why a HashMap works in O(1) time or when to choose a Trie over a HashMap, your interview ends right there.

The good news? Most data structures interview questions follow predictable patterns, and once you understand these 50 essential questions, you’ll walk into any SDE interview with genuine confidence.

This comprehensive guide covers exactly what top tech companies—from startups to FAANG—are asking freshers in 2025. You’ll learn not just the answers, but the thinking process behind them, because that’s what separates candidates who get offers from those who don’t. Let’s dive in.

Table of Contents

Section 1: Arrays and Strings (The Foundation)

Question 1: Find the missing number in an array of 1 to N

Why this matters: This tests your understanding of mathematical properties and optimization. The naive approach uses extra space, but the optimal solution uses the sum formula.

The approach: Calculate the expected sum of numbers from 1 to N using the formula N*(N+1)/2, then subtract the actual sum of array elements. The difference is your missing number. Time complexity: O(n), Space: O(1).

Pro tip: Interviewers often follow up with “What if two numbers are missing?” This requires a slightly different approach using sum of squares.

Question 2: Reverse an array in-place

This seems simple, but it tests your understanding of two-pointer technique and space optimization. Use two pointers—one at start, one at end—and swap elements while moving towards the center. The key learning here is the in-place requirement, which means you cannot use extra space proportional to input size.

Question 3: Find all pairs in an array that sum to a target value

The evolution of thinking: Freshers often start with nested loops (O(n²)). However, the optimal approach uses a HashSet. As you iterate through the array, check if (target – current element) exists in the set. If yes, you’ve found a pair. Otherwise, add the current element to the set.

This question beautifully demonstrates why choosing the right data structure matters. A HashSet gives you O(1) lookup, reducing overall complexity from O(n²) to O(n).

Question 4: Find the maximum subarray sum (Kadane’s Algorithm)

This is where many freshers struggle because the solution isn’t intuitive. Kadane’s algorithm maintains two values: the maximum sum ending at the current position and the global maximum sum. The logic? At each position, you either extend the existing subarray or start fresh from the current element.

Real-world connection: This algorithm is used in stock trading (maximum profit in a period), analyzing weather data, and even in machine learning for feature extraction.

Question 5: Rotate an array by K positions

Multiple approaches exist, but the reversal algorithm is elegant. Reverse the entire array, then reverse the first K elements, then reverse the remaining elements. This works in O(n) time with O(1) space. Understanding this teaches you that sometimes, breaking a problem into smaller steps yields better solutions.

Question 6: Check if a string is a palindrome

Beyond the basic implementation, interviewers want to see how you handle edge cases: empty strings, single characters, spaces, and special characters. The two-pointer approach from both ends is standard, but handling case sensitivity and non-alphanumeric characters separates good answers from great ones.

Question 7: Find the first non-repeating character in a string

This question tests your ability to choose between different data structures. You could use a HashMap to store character frequencies, then iterate again to find the first character with frequency 1. Alternatively, an array of size 256 (for ASCII) works if you want slightly better performance.

Question 8: Implement string compression (e.g., “aaabb” becomes “a3b2”)

The challenge here isn’t the logic but handling edge cases. What if the compressed string is longer than the original? You need to check and return the shorter one. This tests your ability to think about practical constraints.

Question 9: Find all anagrams of a string in another string

This is a sliding window problem combined with character frequency matching. Maintain a frequency map of the pattern string, then slide a window of the same size across the text, comparing frequency maps. This demonstrates your understanding of both HashMaps and the sliding window technique.

Question 10: Longest substring without repeating characters

Another sliding window classic. Use a HashSet to track characters in the current window. When you encounter a duplicate, shrink the window from the left until the duplicate is removed. This question appears frequently because it tests multiple concepts: HashSet operations, two-pointer technique, and optimization thinking.

Section 2: Linked Lists (Pointer Manipulation Mastery)

Question 11: Reverse a linked list

This is the “Hello World” of linked list problems. Both iterative and recursive solutions exist. The iterative approach uses three pointers (previous, current, next) and is more intuitive. However, understanding the recursive solution shows you grasp recursion’s stack-based nature.

Interview insight: Interviewers often ask you to reverse only a portion of the list or reverse in groups of K, so make sure you understand the core reversal logic thoroughly.

Question 12: Detect a cycle in a linked list

Floyd’s cycle detection algorithm (tortoise and hare) is brilliant in its simplicity. Use two pointers moving at different speeds. If there’s a cycle, they’ll eventually meet. This O(n) time, O(1) space solution demonstrates that clever pointer manipulation can solve complex problems elegantly.

Question 13: Find the middle element of a linked list

Again, the fast and slow pointer technique shines. Move one pointer by one step and another by two steps. When the fast pointer reaches the end, the slow pointer is at the middle. This single-pass solution is better than first counting nodes and then traversing again.

Question 14: Merge two sorted linked lists

This tests your ability to handle multiple pointers simultaneously. Compare the heads of both lists, attach the smaller one to your result list, and move forward in that list. Continue until one list is exhausted, then attach the remainder of the other list.

Practical application: This is the foundation of merge sort, which is used in databases and file systems for sorting large datasets.

Question 15: Remove nth node from the end of the list

The one-pass solution uses a clever trick: maintain two pointers with a gap of N nodes between them. When the front pointer reaches the end, the back pointer is at the node to be removed. This demonstrates your ability to solve problems efficiently without multiple passes.

Question 16: Check if a linked list is a palindrome

Multiple approaches exist. You could reverse the second half and compare with the first half, or use a stack. The space-optimal approach reverses the second half in-place, compares, then reverses it back to restore the original list—showing consideration for data integrity.

Question 17: Add two numbers represented by linked lists

Each node contains a single digit, and you need to handle carries properly. This simulates how computers handle large number arithmetic. The key is maintaining a carry variable and creating new nodes for the result list.

Question 18: Flatten a multilevel linked list

This question appears at companies building document editors or hierarchical systems. It tests your understanding of recursion or stack-based iteration through nested structures. The logic involves processing the main list while handling child pointers appropriately.

Question 19: Clone a linked list with random pointers

This is trickier than it seems. You need to copy nodes and maintain the random pointer relationships. The optimal approach interweaves original and copied nodes temporarily, then separates them—a clever use of space without extra data structures.

Question 20: Find the intersection point of two linked lists

Calculate the lengths of both lists, move the pointer of the longer¹ list forward by the difference, then move both pointers together until they meet. This demonstrates mathematical thinking applied to pointer manipulation.

Section 3: Stacks and Queues (Order Management)

Question 21: Implement a stack using arrays

Beyond basic push and pop, discuss overflow handling, dynamic resizing, and why amortized O(1) operations matter. Talk about how ArrayList in Java or vectors in C++ handle dynamic growth—this shows real-world thinking.

Question 22: Implement a queue using stacks

This is a classic design problem. Use two stacks—one for enqueue operations and one for dequeue operations. When dequeue is called and the output stack is empty, transfer all elements from the input stack. This amortizes to O(1) per operation.

Question 23: Check for balanced parentheses

Use a stack to track opening brackets. For each closing bracket, verify it matches the top of the stack. This problem teaches you that stacks naturally handle nested structures—a concept used in compilers and expression parsers.

Question 24: Implement a Min Stack

This asks you to implement a stack that supports push, pop, and getMin operations, all in O(1) time. The solution maintains two stacks—one for actual values and one for tracking the minimum at each state. This demonstrates that sometimes using extra space dramatically improves time complexity.

Real use case: This pattern is used in undo/redo functionality where you need to track states efficiently.

Question 25: Evaluate postfix expression

Stacks are perfect for this. Push operands onto the stack, and when you encounter an operator, pop two operands, apply the operation, and push the result back. This is how calculators and compilers actually evaluate expressions.

Question 26: Next Greater Element

For each element in an array, find the next greater element to its right. The naive O(n²) approach compares each element with all elements to its right. However, using a stack, you can solve this in O(n) by maintaining potential candidates for “next greater” relationships.

Question 27: Implement a Circular Queue

This tests your understanding of modular arithmetic and space optimization. Use an array with front and rear pointers, and use the modulo operator to wrap around. This is used in buffering systems and producer-consumer problems.

Question 28: Design a LRU Cache

This is a favorite among companies building caching systems. Combine a HashMap (for O(1) access) with a doubly linked list (for O(1) insertion/deletion). The HashMap stores key-node pairs, while the list maintains access order. When capacity is reached, remove the least recently used item from the list’s tail.

Industry relevance: Redis, browser caches, and CDNs use variants of LRU caching. With Anthropic’s Claude and similar AI systems processing millions of requests, efficient caching determines system performance.

Question 29: Sliding Window Maximum

Given an array and a window size, find the maximum in each window as it slides. Use a deque (double-ended queue) to maintain indices of potential maximum elements. This O(n) solution is used in image processing and time-series analysis.

Question 30: Stock Span Problem

For each day, calculate how many consecutive days before (including today) had a price less than or equal to today’s price. A stack-based solution tracks indices efficiently, demonstrating how stacks help solve problems involving “previous smaller/greater” relationships.

Section 4: Trees and Binary Search Trees

Question 31: Implement tree traversals (Inorder, Preorder, Postorder)

Master both recursive and iterative versions. Iterative traversals use a stack explicitly, while recursive traversals use the call stack implicitly. Understanding this distinction helps you handle stack overflow scenarios in deep trees.

Connection to real systems: File system traversal, DOM parsing in browsers, and even AI decision trees use these patterns.

Question 32: Find the height/depth of a binary tree

A simple recursive solution that demonstrates tree property calculation. Height equals 1 plus the maximum of left and right subtree heights. This teaches the fundamental pattern of breaking tree problems into subproblems.

Question 33: Check if a binary tree is balanced

A tree is balanced if the height difference between left and right subtrees is at most 1 for every node. The naive approach calculates height repeatedly (O(n²)). The optimal approach calculates height and checks balance simultaneously in a single pass (O(n)).

Question 34: Find the lowest common ancestor of two nodes

Multiple approaches exist based on tree type. For a BST, use the ordering property. For a general binary tree, use recursion to check if nodes are in different subtrees. This demonstrates how tree properties enable optimization.

Question 35: Convert a binary tree to its mirror image

Recursively swap left and right children at every node. This tests your understanding of tree modification and recursion. The problem becomes more interesting if asked to do it iteratively using a queue or stack.

Question 36: Check if two trees are identical

Recursively verify that nodes at corresponding positions have the same value and structure. This teaches you how to process two data structures simultaneously—a pattern useful in diff algorithms.

Question 37: Serialize and deserialize a binary tree

Convert a tree to a string representation and reconstruct it back. Use level-order traversal with markers for null nodes. This is how databases store hierarchical data and how messaging systems transmit tree structures.

Question 38: Find the diameter of a binary tree

The diameter is the longest path between any two nodes. The path may or may not pass through the root. At each node, calculate the diameter as the maximum of: diameter through this node (left height + right height), diameter of left subtree, or diameter of right subtree.

Question 39: Validate a Binary Search Tree

A common mistake is just checking if left child < parent < right child. However, you need to ensure all nodes in the left subtree are smaller and all nodes in the right subtree are larger. Pass valid ranges down the recursion to verify this correctly.

Question 40: Find the kth smallest element in a BST

Inorder traversal of a BST gives sorted elements. You can perform inorder traversal and return the kth element. This demonstrates understanding of BST properties and how traversal order matters.

Section 5: Hashing and Advanced Concepts

Question 41: Implement a HashMap from scratch

This tests deep understanding. Discuss array-based storage, hash function design, collision resolution (chaining vs. open addressing), load factor, and resizing. Explain why Java’s HashMap uses separate chaining with linked lists (converting to trees for buckets with many collisions).

Industry context: With the rise of AI systems processing massive datasets, understanding hashing is crucial. Even Anthropic’s Claude uses hash-based lookups for efficient token processing.

Question 42: Find the first repeating element

Use a HashMap to track elements seen so far. The first element you encounter that’s already in the map is your answer. This O(n) solution demonstrates why hash-based lookups are powerful.

Question 43: Group anagrams together

Use a HashMap where the key is a sorted version of the word (or a frequency map), and the value is a list of anagrams. This shows how creative key design enables efficient grouping.

Question 44: Longest consecutive sequence in an unsorted array

The O(n log n) approach sorts first. However, using a HashSet, you can achieve O(n). Add all elements to the set, then for each element that’s the start of a sequence (no element-1 in set), count consecutive elements. This demonstrates how data structures change algorithmic complexity.

Question 45: Subarray with sum equal to K

Use a HashMap to store cumulative sums. For each position, check if (currentSum – K) exists in the map. This prefix sum technique is used in databases for range queries and in financial systems for period-based calculations.

Question 46: Find all subarrays with XOR equal to K

Similar to the previous problem but using XOR properties. This tests your understanding of both hashing and bit manipulation—a combination that appears in cryptography and data compression algorithms.

Question 47: Implement a Trie (Prefix Tree)

Tries are crucial for autocomplete, spell checkers, and IP routing. Implement insert, search, and startsWith operations. Discuss space vs. time trade-offs—tries use more space but offer faster prefix searches than hash maps.

Question 48: Implement a Graph using adjacency list and matrix

Understand when to use each representation. Adjacency lists are better for sparse graphs (social networks), while matrices are better for dense graphs (road networks in small cities). Discuss space complexity differences.

Question 49: Detect a cycle in a directed graph

Use DFS with three states: unvisited, visiting, and visited. A back edge to a “visiting” node indicates a cycle. This is used in build systems to detect circular dependencies and in compilers for circular reference detection.

Question 50: Find the shortest path in an unweighted graph

BFS naturally finds the shortest path in unweighted graphs because it explores level by level. Maintain a distance array and parent array for path reconstruction. This is the foundation of how GPS systems and network routing protocols work.

Making It All Click: The Preparation Strategy

Understanding these 50 questions isn’t about memorization—it’s about recognizing patterns. Notice how many problems use the two-pointer technique? Or how stacks naturally solve problems involving nested structures or “next greater/smaller” relationships?

Start by implementing each data structure from scratch at least once. Write the code, trace through examples, and break it intentionally to understand edge cases. Then, solve these questions while timing yourself. Companies typically allocate 30-45 minutes for coding rounds, and you need to be comfortable solving at least one problem in that timeframe.

Moreover, practice explaining your thought process out loud. With AI coding tools now available, interviewers care more about your problem-solving approach than perfect syntax. They want to see you: identify the problem type, consider multiple approaches, justify your choice, handle edge cases, and analyze complexity.

The Current Reality: AI’s Impact on SDE Interviews

The software development landscape has shifted significantly with AI assistants. According to recent studies, over 60% of developers now use AI tools like Claude or GitHub Copilot regularly. This has raised the bar for fresher interviews. Companies now assume you can write basic code quickly, so they’re testing a deeper understanding.

Anthropic’s recent advancements in Claude’s reasoning capabilities mean that AI can now assist with debugging and even suggest optimizations. Therefore, interviewers focus on questions where understanding trade-offs matters more than implementation speed. They ask: “Why did you choose a HashMap over a TreeMap here?” or “How would this scale with a million users?”

Your preparation should reflect this shift. Don’t just learn to code solutions—understand why they work, what alternatives exist, and when each approach is best.

Final Thoughts

Image rights: Torrance Memorial Foundation

These 50 questions form the backbone of fresher SDE interviews across the industry. Companies might vary in difficulty or add domain-specific questions, but these fundamentals remain constant.

The key to success isn’t solving all 50 questions once—it’s solving them multiple times until the patterns become second nature.

Create a practice schedule: spend weeks 1-2 on arrays and strings, weeks 3-4 on linked lists and stacks, weeks 5-6 on trees, and week 7 on advanced topics. Then, spend your final week doing mock interviews and timed problem-solving.

Remember, every successful SDE started exactly where you are now. The difference between those who crack interviews and those who don’t often comes down to structured preparation and genuine understanding rather than raw talent. These questions give you the roadmap—now it’s about putting in the focused effort.

Also, join coding communities, participate in discussions, and learn from others’ approaches. Platforms like LeetCode, HackerRank, and Codeforces have active communities where people share multiple solutions and discuss trade-offs. This collaborative learning accelerates your growth.

The opportunities in tech have never been better, and companies are actively hiring freshers who demonstrate solid fundamentals and clear thinking. With the right preparation using these 50 questions as your foundation, you’ll not just crack interviews—you’ll walk in with the confidence that comes from truly understanding your craft.

Your SDE journey begins with mastering these fundamentals. Start today, stay consistent, and trust the process. Good luck!

Top 50 data structures interview questions