Diameter of Binary Tree in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Diameter Calculation on Simple Tree

What is the output of the following TypeScript code that calculates the diameter of a binary tree?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function diameterOfBinaryTree(root: TreeNode | null): number {
  let diameter = 0;
  function depth(node: TreeNode | null): number {
    if (!node) return 0;
    const left = depth(node.left);
    const right = depth(node.right);
    diameter = Math.max(diameter, left + right);
    return Math.max(left, right) + 1;
  }
  depth(root);
  return diameter;
}

const tree = new TreeNode(1, new TreeNode(2, new TreeNode(4), new TreeNode(5)), new TreeNode(3));
console.log(diameterOfBinaryTree(tree));

A 5

B 2

C 4

D 3

💡 Hint

Think about the longest path between any two nodes in the tree.

The diameter is the longest path between two nodes. Here, the longest path is from node 4 to node 3 through nodes 2 and 1, which has length 3 edges.

🧠 Conceptual

intermediate

Understanding Diameter Definition

Which of the following best describes the diameter of a binary tree?

A The number of edges in the longest path between any two nodes.

B The height of the tree from root to the deepest leaf.

C The number of nodes in the longest path between any two nodes.

D The total number of nodes in the tree.

💡 Hint

Diameter counts edges, not nodes.

Diameter is defined as the number of edges on the longest path between any two nodes in the tree.

🔧 Debug

advanced

Identify the Bug in Diameter Calculation

What error will the following TypeScript code produce when calculating the diameter of a binary tree?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function diameterOfBinaryTree(root: TreeNode | null): number {
  let diameter = 0;
  function depth(node: TreeNode | null): number {
    if (!node) return 0;
    const left = depth(node.left);
    const right = depth(node.right);
    diameter = Math.max(diameter, left + right);
    return Math.max(left, right);
  }
  depth(root);
  return diameter;
}

const tree = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(diameterOfBinaryTree(tree));

A The code runs correctly and outputs 2.

B The code outputs 0 because the depth function does not add 1 to the return value.

C The code throws a TypeError due to null reference.

D The code outputs 0 because diameter is never updated.

💡 Hint

Check the return statement of the depth function.

The depth function should return max(left, right) + 1 to count the current node. Missing +1 causes incorrect depth and diameter calculation.

🚀 Application

advanced

Diameter of Unbalanced Binary Tree

Given the following unbalanced binary tree, what is the diameter?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

const tree = new TreeNode(1, new TreeNode(2, new TreeNode(3, new TreeNode(4), null), null), new TreeNode(5));

A 5

B 3

C 4

D 6

💡 Hint

Find the longest path between two nodes in the tree.

The longest path is from node 4 to node 5 through nodes 3, 2, and 1, which has 4 edges.

❓ Predict Output

expert

Output of Diameter Calculation with Multiple Paths

What is the output of the following TypeScript code that calculates the diameter of a binary tree with multiple longest paths?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function diameterOfBinaryTree(root: TreeNode | null): number {
  let diameter = 0;
  function depth(node: TreeNode | null): number {
    if (!node) return 0;
    const left = depth(node.left);
    const right = depth(node.right);
    diameter = Math.max(diameter, left + right);
    return Math.max(left, right) + 1;
  }
  depth(root);
  return diameter;
}

const tree = new TreeNode(1,
  new TreeNode(2, new TreeNode(4), new TreeNode(5)),
  new TreeNode(3, null, new TreeNode(6, new TreeNode(7), null))
);
console.log(diameterOfBinaryTree(tree));

A 5

B 7

C 6

D 4

💡 Hint

Consider all longest paths and count edges.

The longest path is from node 7 to node 5 through nodes 6, 3, 1, and 2, which has 5 edges.