Data Structures Interview Questions and Solved Examples

Why Data Structures Matter in Interviews

Interviewers use data structures questions to test how well you organize data and solve problems efficiently. A correct solution with poor performance is often rejected. Understanding data structures helps you write optimized and scalable code.

Array Interview Question: Find the Maximum Element

Arrays are the most basic data structure. Interviewers often start with simple array traversal questions.

function findMax(arr) {
  let max = arr[0]

  for (let i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
      max = arr[i]
    }
  }

  return max
}

findMax([3, 7, 1, 9, 4])

String Interview Question: Reverse a String

String manipulation questions are very common in interviews and test basic logic.

function reverseString(str) {
  let reversed = ""

  for (let i = str.length - 1; i >= 0; i--) {
    reversed += str[i]
  }

  return reversed
}

reverseString("interview")

Linked List Interview Question: Find Length

Linked lists test understanding of pointers and node traversal.

function getLength(head) {
  let count = 0
  let current = head

  while (current !== null) {
    count++
    current = current.next
  }

  return count
}

Stack Interview Question: Valid Parentheses

Stacks are often used to solve problems involving nested or sequential operations.

function isValidParentheses(str) {
  const stack = []
  const pairs = {
    ")": "(",
    "}": "{",
    "]": "["
  }

  for (let char of str) {
    if (char === "(" || char === "{" || char === "[") {
      stack.push(char)
    } else {
      if (stack.pop() !== pairs[char]) {
        return false
      }
    }
  }

  return stack.length === 0
}

isValidParentheses("(){}[]")

Queue Interview Question: Implement Queue

Queues follow the First In First Out principle and are commonly asked in interviews.

class Queue {
  constructor() {
    this.items = []
  }

  enqueue(element) {
    this.items.push(element)
  }

  dequeue() {
    return this.items.shift()
  }
}

const queue = new Queue()
queue.enqueue(10)
queue.enqueue(20)
queue.dequeue()

Hash Table Interview Question: Find Duplicate Elements

Hash tables help achieve fast lookups and are frequently tested.

function findDuplicates(arr) {
  const map = {}
  const duplicates = []

  for (let num of arr) {
    if (map[num]) {
      duplicates.push(num)
    } else {
      map[num] = true
    }
  }

  return duplicates
}

findDuplicates([1, 2, 3, 2, 4, 1])

Tree Interview Question: Inorder Traversal

Tree traversal questions are common in mid to senior-level interviews.

function inorderTraversal(root) {
  if (root === null) return

  inorderTraversal(root.left)
  console.log(root.value)
  inorderTraversal(root.right)
}

Graph Interview Question: Depth First Search

Graph problems test understanding of recursion and visited tracking.

function dfs(node, visited = new Set()) {
  if (visited.has(node)) return

  visited.add(node)
  console.log(node.value)

  for (let neighbor of node.neighbors) {
    dfs(neighbor, visited)
  }
}

Time and Space Complexity

Interviewers expect candidates to explain time and space complexity. Big O notation describes how an algorithm performs as input size grows.

• O(1): Constant time
• O(n): Linear time
• O(n²): Quadratic time
• O(log n): Logarithmic time

Common Interview Mistakes

Many candidates fail interviews due to avoidable mistakes.

• Not explaining the approach
• Ignoring edge cases
• Poor time complexity
• Writing unreadable code

Best Preparation Tips

Consistent practice and strong fundamentals are key to cracking data structures interviews.

• Practice daily problems
• Focus on fundamentals
• Analyze time complexity
• Explain solutions clearly