Mock Interview Questions

What is a tree data structure?

What are the types of tree data structures?

What is the difference between a tree and a graph?

What is the purpose of tree traversal?

What are the types of tree traversal?

What is the time complexity of tree traversal?

What is the space complexity of tree traversal?

What is a binary tree?

What is a binary search tree?

What is the purpose of a heap?

What is the time complexity of heap operations?

What is the space complexity of a heap?

What is a tree edge?

What is a tree path?

What is the length of a tree path?

What is a tree cycle?

What is the difference between a tree and a forest?

What is the purpose of tree pruning?

What is the purpose of tree grafting?

What is the time complexity of tree pruning?

What is the space complexity of tree pruning?

Write a function to create a binary tree node with a given value.

function TreeNode(value) {
  this.value = value;
  this.left = null;
  this.right = null;
}

Write a function to insert a node into a binary search tree.

function insertNode(root, value) {
  if (root === null) {
    return new TreeNode(value);
  }
  if (value < root.value) {
    root.left = insertNode(root.left, value);
  } else if (value > root.value) {
    root.right = insertNode(root.right, value);
  }
  return root;
}

Write a function to traverse a binary tree using inorder traversal.

function inorderTraversal(root) {
  if (root === null) {
    return;
  }
  inorderTraversal(root.left);
  console.log(root.value);
  inorderTraversal(root.right);
}

Write a function to find the maximum value in a binary tree.

function findMaxValue(root) {
  if (root === null) {
    return -Infinity;
  }
  return Math.max(
    root.value,
    findMaxValue(root.left),
    findMaxValue(root.right)
  );
}

Write a function to find the minimum value in a binary tree.

function findMinValue(root) {
  if (root === null) {
    return Infinity;
  }
  return Math.min(
    root.value,
    findMinValue(root.left),
    findMinValue(root.right)
  );
}

Write a function to check if a binary tree is balanced.

function isBalanced(root) {
  if (root === null) {
    return true;
  }
  const leftHeight = getHeight(root.left);
  const rightHeight = getHeight(root.right);
  return (
    Math.abs(leftHeight - rightHeight) <= 1 &&
    isBalanced(root.left) &&
    isBalanced(root.right)
  );
}
function getHeight(root) {
  if (root === null) {
    return 0;
  }
  return 1 + Math.max(getHeight(root.left), getHeight(root.right));
}

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

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

Write a function to find the path from the root to a given node in a binary tree.

function findPath(root, target) {
  if (root === null) {
    return null;
  }
  if (root === target) {
    return [root];
  }
  const left = findPath(root.left, target);
  if (left) {
    return [root].concat(left);
  }
  const right = findPath(root.right, target);
  if (right) {
    return [root].concat(right);
  }
  return null;
}

Write a function to find the diameter of a binary tree.

function findDiameter(root) {
  if (root === null) {
    return 0;
  }
  const leftHeight = getHeight(root.left);
  const rightHeight = getHeight(root.right);
  return Math.max(
    leftHeight + rightHeight,
    findDiameter(root.left),
    findDiameter(root.right)
  );
}
function getHeight(root) {
  if (root === null) {
    return 0;
  }
  return 1 + Math.max(getHeight(root.left), getHeight(root.right));
}

Write a function to find the maximum sum of a path from the root to a leaf node in a binary tree.

function findMaxSum(root) {
  if (root === null) {
    return -Infinity;
  }
  if (root.left === null && root.right === null) {
    return root.value;
  }
  return root.value + Math.max(findMaxSum(root.left), findMaxSum(root.right));
}