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.