Top data structures interview questions

Schedule a mock interview

for Data structures

Full name *

Email *

Phone number *

Real interview questions from top companies for Data structures. Includes theoretical concepts and coding problems.

What is the difference between a stack and a queue?

What are the advantages of using a linked list over an array?

What is the time complexity of searching an element in a binary search tree?

What is the purpose of a hash table?

What is the difference between a graph and a tree?

What is the time complexity of inserting an element into a heap?

What is the purpose of a trie data structure?

What is the difference between a depth-first search and a breadth-first search?

What is the time complexity of finding the minimum element in a stack?

What is the purpose of a disjoint set data structure?

What is the time complexity of inserting an element into a balanced binary search tree?

What is the difference between a min-heap and a max-heap?

What is the purpose of a segment tree data structure?

What is the time complexity of finding the maximum element in a heap?

What is the difference between a sparse matrix and a dense matrix?

What is the purpose of a suffix tree data structure?

What is the time complexity of inserting an element into a hash table?

What is the difference between a graph and a digraph?

What is the purpose of a bloom filter data structure?

What is the time complexity of finding the minimum element in a heap?

Write a function to reverse a linked list

function reverseList(head) {
  let prev = null;
  let curr = head;
  while (curr) {
    let next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }
  return prev;
}

Write a function to find the middle element of a linked list

function findMiddle(head) {
  let slow = head;
  let fast = head;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next.next;
  }
  return slow;
}

Write a function to check if a binary tree is balanced

function isBalanced(root) {
  function check(node) {
    if (!node) return 0;
    let left = check(node.left);
    let right = check(node.right);
    if (left === -1 || right === -1 || Math.abs(left - right) > 1) return -1;
    return 1 + Math.max(left, right);
  }
  return check(root) !== -1;
}

Write a function to find the lowest common ancestor of two nodes in a binary tree

function lowestCommonAncestor(root, p, q) {
  if (!root) return null;
  if (root === p || root === q) return root;
  let left = lowestCommonAncestor(root.left, p, q);
  let right = lowestCommonAncestor(root.right, p, q);
  if (left && right) return root;
  return left ? left : right;
}

Write a function to validate a binary search tree

function isValidBST(root) {
  function check(node, min, max) {
    if (!node) return true;
    if (node.val <= min || node.val >= max) return false;
    return check(node.left, min, node.val) && check(node.right, node.val, max);
  }
  return check(root, -Infinity, Infinity);
}

Write a function to find the maximum depth of a binary tree

function maxDepth(root) {
  if (!root) return 0;
  return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

Write a function to find the minimum depth of a binary tree

function minDepth(root) {
  if (!root) return 0;
  if (!root.left) return 1 + minDepth(root.right);
  if (!root.right) return 1 + minDepth(root.left);
  return 1 + Math.min(minDepth(root.left), minDepth(root.right));
}

Write a function to find the maximum sum of a subarray

function maxSubArray(nums) {
  let max = nums[0];
  let sum = nums[0];
  for (let i = 1; i < nums.length; i++) {
    sum = Math.max(nums[i], sum + nums[i]);
    max = Math.max(max, sum);
  }
  return max;
}

Write a function to find the first duplicate in an array

function firstDuplicate(arr) {
  let set = new Set();
  for (let num of arr) {
    if (set.has(num)) return num;
    set.add(num);
  }
  return -1;
}