Data Structures and Algorithms

DSA Interview Questions

DSA Mock Test: 30 Questions to Test Your Interview Readiness

Hey there, aspiring tech pro! If you’re gearing up for that big interview at a FAANG company or any top-tier tech firm, you know Data Structures and Algorithms (DSA) can make or break your chances. This mock test is designed to mimic real interview scenarios, pulling from questions that have actually popped up in recent interviews at places like Google, Amazon, and Meta. Whether you’re a fresh grad or switching roles, practicing these will sharpen your skills and boost your confidence. And if you’re eager to dive deeper with structured learning, sign up for our free course updates and get the latest on DSA mastery tailored for interviews.

In this post, we’ll cover why DSA is a staple in interviews, how to prep effectively, and then dive into 30 handpicked questions with in-depth explanations. These aren’t just random picks—they’re drawn from real experiences shared on platforms like LeetCode, GeeksforGeeks, and Reddit discussions from 2024-2025. Let’s get you interview-ready!

Why DSA Matters in Tech Interviews

Imagine walking into an interview at Amazon or Google without a solid grasp of DSA—it’s like showing up to a marathon in flip-flops. DSA questions test your problem-solving chops, efficiency in coding, and ability to think under pressure. According to recent reports from Interviewing.io, over 70% of technical interviews at FAANG companies revolve around DSA, with a focus on arrays, strings, trees, and graphs. Why? Because these concepts underpin everything from optimizing search engines to building scalable apps.

In 2025, with AI and machine learning booming, DSA remains king. A GeeksforGeeks survey from September 2025 shows that candidates who aced DSA rounds had a 40% higher hire rate. Real talk: companies like Meta ask these to see if you can optimize code for billions of users. For instance, LRU Cache questions often appear in Amazon interviews because they mirror cache management in their e-commerce systems.

Actionable advice: Track your progress by timing yourself on these questions. Aim for under 45 minutes per medium-level problem, as that’s the typical interview slot.

How to Prepare for DSA Interviews

Preparation isn’t about cramming—it’s about building a toolkit. Start with fundamentals: understand time and space complexity (Big O notation) because interviewers love asking “Can you optimize this?” Resources like our DSA course can guide you through structured practice.

Here’s a step-by-step plan:

Master Core Topics: Focus on arrays, linked lists, stacks, queues, trees, graphs, and dynamic programming. Use platforms like LeetCode or GeeksforGeeks for daily practice.
Practice Mock Interviews: Simulate real scenarios with tools or peers. Sites like Pramp offer free mocks.
Review Real Questions: Dive into company-specific lists. For broader skills, check our master DSA, web dev, and system design course to connect DSA with real-world applications.
Analyze Mistakes: After each question, note what went wrong— was it edge cases or implementation?
Stay Updated: Tech evolves; follow 2025 trends like graph algorithms for social networks, relevant for Meta interviews.

If you’re short on time, our crash course condenses essentials into bite-sized modules. Pair this with related fields like web development for full-stack roles or data science if you’re eyeing analytical positions.

Pro tip: Explain your thought process out loud during practice—interviewers value communication as much as code.

The DSA Mock Test: 30 Essential Questions

Ready to test yourself? These 30 questions are curated from actual interviews at Google, Amazon, Meta, and others in 2024-2025. They’ve been reported in Reddit threads, Medium posts, and GeeksforGeeks compilations. I’ve grouped them by topic for easy navigation. For each, you’ll find the problem statement, optimal approach, sample code (in Python for simplicity), time/space complexity, and tips from real interviews.

Array Questions

Two Sum: Given an array of integers nums and an integer target, return indices of two numbers that add up to target. Approach: Use a hash map to store seen numbers and their indices. For each num, check if target – num exists in the map. This avoids O(n^2) brute force. Code:

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

Complexity: Time O(n), Space O(n). Interview Tip: Amazon loves this for its simplicity; discuss duplicates as edge cases.

Best Time to Buy and Sell Stock: Given prices array, find max profit from one buy/sell. Approach: Track min price seen, update max profit if current – min > max. Code:

				
					def maxProfit(prices):  
    min_price = float('inf')  
    max_profit = 0  
    for price in prices:  
        min_price = min(min_price, price)  
        max_profit = max(max_profit, price - min_price)  
    return max_profit

Complexity: Time O(n), Space O(1). Tip: Google variants allow multiple transactions; explain dynamic programming extension.

Majority Element: Find element appearing > n/2 times in array. Approach: Boyer-Moore Voting: Increment vote for candidate, reset if zero. Code:

				
					def majorityElement(nums):  
    count = 0  
    candidate = None  
    for num in nums:  
        if count == 0:  
            candidate = num  
        count += (1 if num == candidate else -1)  
    return candidate

Complexity: Time O(n), Space O(1). Tip: Meta asks follow-ups on no majority case.

Maximum Subarray: Find contiguous subarray with largest sum. Approach: Kadane’s algorithm: Track current max and global max. Code:

				
					def maxSubArray(nums):  
    max_current = max_global = nums[0]  
    for num in nums[1:]:  
        max_current = max(num, max_current + num)  
        max_global = max(max_global, max_current)  
    return max_global

Complexity: Time O(n), Space O(1). Tip: Handle all-negative arrays.

Merge Intervals: Given intervals, merge overlapping ones. Approach: Sort by start, merge if current end >= next start. Code:

				
					def merge(intervals):  
    intervals.sort(key=lambda x: x[0])  
    merged = []  
    for interval in intervals:  
        if not merged or merged[-1][1] < interval[0]:  
            merged.append(interval)  
        else:  
            merged[-1][1] = max(merged[-1][1], interval[1])  
    return merged

Complexity: Time O(n log n), Space O(n). Tip: Amazon uses for scheduling.

Product of Array Except Self: Compute product array without division. Approach: Left and right passes for prefixes/suffixes. Code:

				
					def productExceptSelf(nums):  
    n = len(nums)  
    left = [1] * n  
    for i in range(1, n):  
        left[i] = left[i-1] * nums[i-1]  
    right = 1  
    for i in range(n-1, -1, -1):  
        temp = nums[i]  
        nums[i] = left[i] * right  
        right *= temp  
    return nums

Complexity: Time O(n), Space O(1) excluding output. Tip: Handle zeros carefully.

String Questions

Valid Anagram: Check if two strings are anagrams. Approach: Sort or use counter hash. Code:

				
					from collections import Counter  
def isAnagram(s, t):  
    return Counter(s) == Counter(t)

Complexity: Time O(n), Space O(n). Tip: Unicode handling in interviews.

Longest Substring Without Repeating Characters: Find length. Approach: Sliding window with set for unique chars. Code:

				
					def lengthOfLongestSubstring(s):  
    char_set = set()  
    left = max_length = 0  
    for right in range(len(s)):  
        while s[right] in char_set:  
            char_set.remove(s[left])  
            left += 1  
        char_set.add(s[right])  
        max_length = max(max_length, right - left + 1)  
    return max_length

Complexity: Time O(n), Space O(n). Tip: Optimize with dict for last index.

Group Anagrams: Group list of strings by anagrams. Approach: Use sorted string as key in dict. Code:

				
					
def groupAnagrams(strs):  
    anagrams = {}  
    for s in strs:  
        key = ''.join(sorted(s))  
        anagrams.setdefault(key, []).append(s)  
    return list(anagrams.values())

Complexity: Time O(n k log k), Space O(n k). Tip: Common in Google string rounds.

Longest Palindromic Substring: Find it. Approach: Expand around centers. Code:

				
					def longestPalindrome(s):  
    def expand(left, right):  
        while left >= 0 and right < len(s) and s[left] == s[right]:  
            left -= 1  
            right += 1  
        return s[left+1:right]  
    result = ''  
    for i in range(len(s)):  
        odd = expand(i, i)  
        even = expand(i, i+1)  
        result = max(result, odd, even, key=len)  
    return result

Complexity: Time O(n^2), Space O(1). Tip: DP alternative for optimization.

Valid Parentheses: Check balanced. Approach: Stack for matching. Code:

				
					def isValid(s):  
    stack = []  
    mapping = {')': '(', '}': '{', ']': '['}  
    for char in s:  
        if char in mapping:  
            if not stack or stack.pop() != mapping[char]:  
                return False  
        else:  
            stack.append(char)  
    return not stack

Complexity: Time O(n), Space O(n). Tip: Extend to multi-types.

Implement strStr(): Find needle in haystack. Approach: KMP or simple slide. Code:

				
					def strStr(haystack, needle):  
    if not needle: return 0  
    for i in range(len(haystack) - len(needle) + 1):  
        if haystack[i:i+len(needle)] == needle:  
            return i  
    return -1

Complexity: Time O(n m), Space O(1). Tip: Discuss KMP for efficiency.

Linked List Questions

Reverse Linked List: Reverse it. Approach: Iterative pointers. Code: (Assume ListNode class)

				
					def reverseList(head):  
    prev = None  
    current = head  
    while current:  
        next_temp = current.next  
        current.next = prev  
        prev = current  
        current = next_temp  
    return prev

Complexity: Time O(n), Space O(1). Tip: Recursive variant in Meta.

Merge Two Sorted Lists: Merge. Approach: Dummy node, compare. Code:

				
					def mergeTwoLists(l1, l2):  
    dummy = ListNode(0)  
    tail = dummy  
    while l1 and l2:  
        if l1.val < l2.val:  
            tail.next = l1  
            l1 = l1.next  
        else:  
            tail.next = l2  
            l2 = l2.next  
        tail = tail.next  
    tail.next = l1 or l2  
    return dummy.next

Complexity: Time O(n+m), Space O(1). Tip: K-lists extension.

Linked List Cycle: Detect cycle. Approach: Floyd’s tortoise-hare. Code:

				
					def hasCycle(head):  
    slow = fast = head  
    while fast and fast.next:  
        slow = slow.next  
        fast = fast.next.next  
        if slow == fast:  
            return True  
    return False

Complexity: Time O(n), Space O(1). Tip: Find cycle start follow-up.

Remove Nth Node From End of List: Remove. Approach: Two pointers, delay one. Code:

				
					def removeNthFromEnd(head, n):  
    dummy = ListNode(0, head)  
    first = second = dummy  
    for _ in range(n+1):  
        first = first.next  
    while first:  
        first = first.next  
        second = second.next  
    second.next = second.next.next  
    return dummy.next

Complexity: Time O(n), Space O(1). Tip: Handle n=length.

Add Two Numbers: Add linked lists as numbers. Approach: Carry over. Code

				
					def addTwoNumbers(l1, l2):  
    dummy = ListNode(0)  
    tail = dummy  
    carry = 0  
    while l1 or l2 or carry:  
        val1 = l1.val if l1 else 0  
        val2 = l2.val if l2 else 0  
        total = val1 + val2 + carry  
        carry = total // 10  
        tail.next = ListNode(total % 10)  
        tail = tail.next  
        l1 = l1.next if l1 else None  
        l2 = l2.next if l2 else None  
    return dummy.next

Complexity: Time O(max(n,m)), Space O(max(n,m)). Tip: Reverse input variant.

Advanced Data Structures

LRU Cache: Design with get/put. Approach: Dict + doubly linked list. Code: (Simplified

				
					class LRUCache:  
    def __init__(self, capacity):  
        self.capacity = capacity  
        self.cache = {}  
        self.head = ListNode(0, 0)  
        self.tail = ListNode(0, 0)  
        self.head.next = self.tail  
        self.tail.prev = self.head  
    # Add more methods for get, put, remove, add

Complexity: Time O(1) per op, Space O(capacity). Tip: Amazon staple; explain eviction.

Maximum Depth of Binary Tree: Find max depth. Approach: Recursion. Code:

				
					def maxDepth(root):  
    if not root: return 0  
    return 1 + max(maxDepth(root.left), maxDepth(root.right))

Complexity: Time O(n), Space O(n). Tip: BFS alternative.

Same Tree: Check identical. Approach: Recurse structure/value. Code:

				
					def isSameTree(p, q):  
    if not p and not q: return True  
    if not p or not q or p.val != q.val: return False  
    return isSameTree(p.left, q.left) and isSameTree(p.right, q.right)

Complexity: Time O(n), Space O(n). Tip: Subtree variant.

Invert Binary Tree: Flip. Approach: Recurse swap children. Code:
python

				
					def invertTree(root):  
    if root:  
        root.left, root.right = invertTree(root.right), invertTree(root.left)  
    return root

Complexity: Time O(h), Space O(1). Tip: Binary tree version harder.

Serialize and Deserialize Binary Tree: Codec. Approach: Preorder traversal string. Code: (Omitted for brevity; use queue for deserialize). Complexity: Time O(n), Space O(n). Tip: Handle nulls.

Diameter of Binary Tree: Longest path. Approach: Recurse depth, track max. Code:

				
					def diameterOfBinaryTree(root):  
    def depth(node):  
        nonlocal diameter  
        if not node: return 0  
        left = depth(node.left)  
        right = depth(node.right)  
        diameter = max(diameter, left + right)  
        return 1 + max(left, right)  
    diameter = 0  
    depth(root)  
    return diameter

Complexity: Time O(n), Space O(n). Tip: Edge cases.

Graph Questions

Number of Islands: Count ‘1’ groups in grid. Approach: DFS/BFS flood fill. Code: (DFS)

				
					def numIslands(grid):  
    if not grid: return 0  
    rows, cols = len(grid), len(grid[0])  
    visit = set()  
    islands = 0  
    def dfs(r, c):  
        if (r < 0 or c < 0 or r == rows or c == cols or  
            grid[r][c] == '0' or (r, c) in visit):  
            return  
        visit.add((r, c))  
        dfs(r+1, c)  
        dfs(r-1, c)  
        dfs(r, c+1)  
        dfs(r, c-1)  
    for r in range(rows):  
        for c in range(cols):  
            if grid[r][c] == '1' and (r, c) not in visit:  
                dfs(r, c)  
                islands += 1  
    return islands

Complexity: Time O(m n), Space O(m n). Tip: Union-find alternative.

Clone Graph: Deep copy. Approach: DFS with visited map. Code:

				
					def cloneGraph(node):  
    if not node: return None  
    visited = {}  
    def dfs(n):  
        if n in visited: return visited[n]  
        copy = Node(n.val)  
        visited[n] = copy  
        copy.neighbors = [dfs(nei) for nei in n.neighbors]  
        return copy  
    return dfs(node)

Complexity: Time O(n+e), Space O(n). Tip: BFS queue.

Course Schedule: Detect cycle in prerequisites. Approach: Topological sort Kahn’s. Code:

				
					from collections import deque, defaultdict  
def canFinish(numCourses, prerequisites):  
    graph = defaultdict(list)  
    indegree = [0] * numCourses  
    for a, b in prerequisites:  
        graph[b].append(a)  
        indegree[a] += 1  
    q = deque([i for i in range(numCourses) if indegree[i] == 0])  
    count = 0  
    while q:  
        node = q.popleft()  
        count += 1  
        for nei in graph[node]:  
            indegree[nei] -= 1  
            if indegree[nei] == 0:  
                q.append(nei)  
    return count == numCourses

Complexity: Time O(n+e), Space O(n+e). Tip: DFS cycle detect.

Pacific Atlantic Water Flow: Cells reaching both oceans. Approach: DFS from edges. Code: (Omitted; two sets for oceans). Complexity: Time O(m n), Space O(m n). Tip: Multi-source BFS.

Word Ladder: Shortest transformation sequence. Approach: BFS with wildcards. Code:

				
					from collections import deque  
def ladderLength(beginWord, endWord, wordList):  
    wordSet = set(wordList)  
    if endWord not in wordSet: return 0  
    q = deque([(beginWord, 1)])  
    while q:  
        word, steps = q.popleft()  
        if word == endWord: return steps  
        for i in range(len(word)):  
            for c in 'abcdefghijklmnopqrstuvwxyz':  
                newWord = word[:i] + c + word[i+1:]  
                if newWord in wordSet:  
                    wordSet.remove(newWord)  
                    q.append((newWord, steps + 1))  
    return 0

Complexity: Time O(m^2 n), Space O(m n). Tip: Bidirectional BFS.

Set Matrix Zeroes: Zero rows/cols with zero. Approach: Use first row/col as flags. Code:

				
					def setZeroes(matrix):  
    rows, cols = len(matrix), len(matrix[0])  
    col0 = False  
    for r in range(rows):  
        if matrix[r][0] == 0: col0 = True  
        for c in range(1, cols):  
            if matrix[r][c] == 0:  
                matrix[r][0] = matrix[0][c] = 0  
    for r in range(1, rows):  
        for c in range(1, cols):  
            if matrix[r][0] == 0 or matrix[0][c] == 0:  
                matrix[r][c] = 0  
    if matrix[0][0] == 0:  
        for c in range(cols): matrix[0][c] = 0  
    if col0:  
        for r in range(rows): matrix[r][0] = 0

Complexity: Time O(m n), Space O(1). Tip: Common in matrix problems.

Tips for Acing Your DSA Interview

Beyond practice, remember: Communicate your thinking. If stuck, ask clarifying questions. Optimize step-by-step. Post-interview, reflect on weak areas—maybe brush up via our DSA course.

Common pitfalls: Ignoring edge cases (empty inputs, max sizes). Stats show 60% of rejections stem from this.

Conclusion

You’ve just tackled a solid DSA mock test—how’d you do? These questions, straight from real interviews, should give you an edge. Keep practicing, and you’ll be ready for anything. Ready to level up? Explore our master course for integrated learning. Drop a comment on your toughest question, and good luck landing that dream job!

DSA, High & Low Level System Designs

85+ Live Classes & Recordings
24*7 Live Doubt Support
400+ DSA Practice Questions
Comprehensive Notes
HackerRank Tests & Quizzes
Topic-wise Quizzes
Case Studies
Access to Global Peer Community

Buy for 52% OFF
₹25,000.00 ₹11,999.00

Accelerate your Path to a Product based Career

Boost your career or get hired at top product-based companies by joining our expertly crafted courses. Gain practical skills and real-world knowledge to help you succeed.

Reach Out Now

If you have any queries, please fill out this form. We will surely reach out to you.

Contact Email

Reach us at the following email address.

arun@getsdeready.com

Phone Number

You can reach us by phone as well.

+91-97737 28034

Our Location

Rohini, Sector-3, Delhi-110085

DSA Mock Test: 30 Questions to Test Your Interview Readiness

Why DSA Matters in Tech Interviews

How to Prepare for DSA Interviews

The DSA Mock Test: 30 Essential Questions

Array Questions

String Questions

Linked List Questions

Advanced Data Structures

Graph Questions

Clone Graph: Deep copy. Approach: DFS with visited map. Code:

Tips for Acing Your DSA Interview

Conclusion

DSA, High & Low Level System Designs

Buy for 52% OFF
₹25,000.00 ₹11,999.00

Accelerate your Path to a Product based Career

SDE 360: Master DSA, System Design, AI & Behavioural

Buy for 50% OFF
₹39,999.00 ₹19,999.00

Mental Ability

DSA, High & Low Level System Designs

Buy for 52% OFF
₹25,000.00 ₹11,999.00

Fast-Track to Full Spectrum Software Engineering

Buy for 51% OFF
₹35,000.00 ₹16,999.00

Low & High Level System Design

Buy for 60% OFF
₹20,000.00 ₹7,999.00

Mastering Mern Stack (WEB DEVELOPMENT)

Buy for 53% OFF
₹15,000.00 ₹6,999.00

Reach Out Now

Contact Email

Phone Number

Our Location

Quick Links

Quick Links

Social Media

DSA Mock Test: 30 Questions to Test Your Interview Readiness

Why DSA Matters in Tech Interviews

How to Prepare for DSA Interviews

The DSA Mock Test: 30 Essential Questions

Array Questions

String Questions

Linked List Questions

Advanced Data Structures

Graph Questions

Clone Graph: Deep copy. Approach: DFS with visited map. Code:

Tips for Acing Your DSA Interview

Conclusion

DSA, High & Low Level System Designs

Buy for 52% OFF ₹25,000.00 ₹11,999.00

Accelerate your Path to a Product based Career

SDE 360: Master DSA, System Design, AI & Behavioural

Buy for 50% OFF ₹39,999.00 ₹19,999.00

Mental Ability

DSA, High & Low Level System Designs

Buy for 52% OFF ₹25,000.00 ₹11,999.00

Fast-Track to Full Spectrum Software Engineering

Buy for 51% OFF ₹35,000.00 ₹16,999.00

Low & High Level System Design

Buy for 60% OFF ₹20,000.00 ₹7,999.00

Mastering Mern Stack (WEB DEVELOPMENT)

Buy for 53% OFF ₹15,000.00 ₹6,999.00

Reach Out Now

Contact Email

Phone Number

Our Location

Quick Links

Quick Links

Social Media

Master Your Interviews with Our Free Roadmap!

Hi Instagram Fam! Get a FREE Cheat Sheet on System Design.

Hi LinkedIn Fam! Get a FREE Cheat Sheet on System Design

Loved Our YouTube Videos? Get a FREE Cheat Sheet on System Design.

Buy for 52% OFF
₹25,000.00 ₹11,999.00

Buy for 50% OFF
₹39,999.00 ₹19,999.00

Buy for 52% OFF
₹25,000.00 ₹11,999.00

Buy for 51% OFF
₹35,000.00 ₹16,999.00

Buy for 60% OFF
₹20,000.00 ₹7,999.00

Buy for 53% OFF
₹15,000.00 ₹6,999.00

Hi Instagram Fam!
Get a FREE Cheat Sheet on System Design.

Hi LinkedIn Fam!
Get a FREE Cheat Sheet on System Design