Diameter of Binary Tree in DSA Go - Build from Scratch

Diameter of Binary Tree

📖 Scenario: You are working on a network system where each node represents a server. The longest path between any two servers in the network is important for understanding the maximum communication delay. This longest path is called the diameter of the network tree.We will represent the network as a binary tree, where each node can have up to two child nodes (servers connected directly).

🎯 Goal: Build a Go program to calculate the diameter of a binary tree. The diameter is the number of nodes on the longest path between any two leaf nodes.

📋 What You'll Learn

Create a binary tree node struct called TreeNode with Val, Left, and Right fields

Create a sample binary tree with exactly 5 nodes with values 1, 2, 3, 4, 5 arranged as specified

Create a helper variable maxDiameter to track the maximum diameter found

Write a recursive function depth that returns the depth of a node and updates maxDiameter

Print the final diameter stored in maxDiameter

💡 Why This Matters

🌍 Real World

Network engineers use tree diameter to understand the longest communication delay in hierarchical networks.

💼 Career

Software developers and system architects often need to analyze tree structures for performance and optimization.

1

Create the binary tree structure and sample tree

Create a struct called TreeNode with fields Val int, Left *TreeNode, and Right *TreeNode. Then create a binary tree with root node value 1, left child 2, right child 3, left child of node 2 as 4, and right child of node 2 as 5. Store the root in a variable called root.

DSA Go

// Define TreeNode struct and create the tree
// Your code here

Hint

Define the struct first, then create nodes using &TreeNode{Val: value} and link them.

2

Add a variable to track the maximum diameter

Inside the main function, create an integer variable called maxDiameter and set it to 0. This will keep track of the longest path found so far.

DSA Go

package main

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Left.Right = &TreeNode{Val: 5}
    // Create maxDiameter variable
    // Your code here
}

Hint

Declare maxDiameter as an integer and initialize it to zero inside main.

3

Write the recursive depth function to update diameter

Write a recursive function called depth that takes a *TreeNode and returns an int. It should return 0 if the node is nil. Otherwise, it should recursively find the depth of left and right children, update maxDiameter with the sum of left and right depths if larger, and return the maximum depth plus 1. Call depth(root) inside main.

DSA Go

package main

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Left.Right = &TreeNode{Val: 5}

    maxDiameter := 0

    // Write depth function and call it
    // Your code here
}

Hint

Use a recursive function that returns 0 for nil nodes, calculates left and right depths, updates maxDiameter, and returns max depth + 1.

4

Print the diameter of the binary tree

Add a fmt.Println statement inside main to print the value of maxDiameter.

DSA Go

package main

import "fmt"

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func main() {
    root := &TreeNode{Val: 1}
    root.Left = &TreeNode{Val: 2}
    root.Right = &TreeNode{Val: 3}
    root.Left.Left = &TreeNode{Val: 4}
    root.Left.Right = &TreeNode{Val: 5}

    maxDiameter := 0

    var depth func(node *TreeNode) int
    depth = func(node *TreeNode) int {
        if node == nil {
            return 0
        }
        leftDepth := depth(node.Left)
        rightDepth := depth(node.Right)
        if leftDepth+rightDepth > maxDiameter {
            maxDiameter = leftDepth + rightDepth
        }
        if leftDepth > rightDepth {
            return leftDepth + 1
        }
        return rightDepth + 1
    }

    depth(root)

    // Print maxDiameter
    // Your code here
}

Hint

Use fmt.Println(maxDiameter) to display the diameter.

Practice

1. What does the diameter of a binary tree represent?

easy

A. The length of the longest path between any two nodes in the tree

B. The number of nodes in the tree

C. The height of the tree

D. The number of leaf nodes in the tree

Solution

1. Step 1: Understand the diameter definition

   The diameter is the longest path between any two nodes, which may or may not pass through the root.

2. Step 2: Differentiate from other tree properties

   Height is the longest path from root to leaf, number of nodes counts all nodes, leaves count only leaf nodes.

3. Final Answer:

   The length of the longest path between any two nodes in the tree -> Option A

4. Quick Check:

   Diameter = longest path between nodes [OK]

Hint: Diameter is longest path, not height or node count [OK]

Common Mistakes:

• Confusing diameter with height
• Thinking diameter counts nodes instead of edges
• Assuming diameter must pass through root

2. Which Go function signature correctly represents a helper function to compute the height of a binary tree node for diameter calculation?

easy

A. func height(node int) int

B. func height(node *TreeNode) int

C. func height(node *TreeNode) bool

D. func height(node TreeNode) string

Solution

1. Step 1: Identify correct parameter type

   The function should accept a pointer to TreeNode to handle nil nodes and avoid copying.

2. Step 2: Identify correct return type

   Height is an integer value representing depth, so return type must be int.

3. Final Answer:

   func height(node *TreeNode) int -> Option B

4. Quick Check:

   Pointer input and int output for height [OK]

Hint: Height function uses pointer receiver and returns int [OK]

Common Mistakes:

• Using value receiver instead of pointer
• Returning wrong type like string or bool
• Passing int instead of TreeNode pointer

3. Given the following Go code snippet, what is the diameter of the binary tree?

type TreeNode struct {
    Val int
    Left *TreeNode
    Right *TreeNode
}

root := &TreeNode{Val: 1}
root.Left = &TreeNode{Val: 2}
root.Right = &TreeNode{Val: 3}
root.Left.Left = &TreeNode{Val: 4}
root.Left.Right = &TreeNode{Val: 5}

// Diameter function uses height helper internally
func diameterOfBinaryTree(root *TreeNode) int {
    maxDiameter := 0
    var height func(node *TreeNode) int
    height = func(node *TreeNode) int {
        if node == nil {
            return 0
        }
        leftHeight := height(node.Left)
        rightHeight := height(node.Right)
        if leftHeight+rightHeight > maxDiameter {
            maxDiameter = leftHeight + rightHeight
        }
        if leftHeight > rightHeight {
            return leftHeight + 1
        }
        return rightHeight + 1
    }
    height(root)
    return maxDiameter
}

fmt.Println(diameterOfBinaryTree(root))

medium

A. 4

B. 2

C. 3

D. 5

Solution

1. Step 1: Calculate heights of subtrees

   Left subtree of root has height 2 (nodes 2->4 or 2->5), right subtree height is 1 (node 3).

2. Step 2: Calculate diameter as sum of left and right heights

   Diameter = leftHeight + rightHeight = 2 + 1 = 3 edges, but diameter counts edges, so longest path is 3 edges which means 4 nodes.

3. Final Answer:

   3 -> Option C

4. Quick Check:

   Longest path length = 3 edges [OK]

Hint: Diameter = sum of left and right subtree heights at max node [OK]

Common Mistakes:

• Counting nodes instead of edges for diameter
• Ignoring one subtree height
• Confusing height with diameter

4. Identify the bug in this Go code snippet for computing the diameter of a binary tree:

func diameterOfBinaryTree(root *TreeNode) int {
    maxDiameter := 0
    var height func(node *TreeNode) int
    height = func(node *TreeNode) int {
        if node == nil {
            return 0
        }
        leftHeight := height(node.Left)
        rightHeight := height(node.Right)
        maxDiameter = leftHeight + rightHeight
        if leftHeight > rightHeight {
            return leftHeight + 1
        }
        return rightHeight + 1
    }
    height(root)
    return maxDiameter
}

medium

A. Function does not call height recursively

B. height function returns wrong type

C. Missing base case for nil node

D. maxDiameter is overwritten without checking max value

Solution

1. Step 1: Analyze maxDiameter update

   maxDiameter is assigned leftHeight + rightHeight every time, overwriting previous max without comparison.

2. Step 2: Correct maxDiameter update

   Should update maxDiameter only if leftHeight + rightHeight is greater than current maxDiameter.

3. Final Answer:

   maxDiameter is overwritten without checking max value -> Option D

4. Quick Check:

   Use max check before assignment [OK]

Hint: Update maxDiameter only if new value is greater [OK]

Common Mistakes:

• Overwriting maxDiameter without max check
• Forgetting base case for nil node
• Not calling height recursively

5. You want to find the diameter of a binary tree but also return the path nodes forming that diameter. Which approach correctly extends the diameter calculation in Go?

hard

A. Modify height function to return both height and path, update max path when diameter increases

B. Calculate diameter first, then do a separate BFS to find path

C. Store all paths in a global slice and pick the longest after traversal

D. Use only height function and return diameter length without path

Solution

1. Step 1: Extend height function to track paths

   Modify the recursive height function to return both height and the path nodes from current node to leaf.

2. Step 2: Update max diameter and store path

   When leftHeight + rightHeight exceeds maxDiameter, update maxDiameter and store concatenated path from left and right subtrees through current node.

3. Step 3: Return stored path after traversal

   After full traversal, return the stored path representing the diameter.

4. Final Answer:

   Modify height function to return both height and path, update max path when diameter increases -> Option A

5. Quick Check:

   Track height and path together for diameter path [OK]

Hint: Return height and path from helper to track diameter path [OK]

Common Mistakes:

• Trying to find path after diameter without tracking
• Storing all paths wastes memory
• Ignoring path tracking in recursion