Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Golang program to find the diameter of a tree
In this Golang article, we are going to find the diameter of a tree by using recursion and iterative method. The diameter of a tree is the number of nodes on the longest path between any two leaves in the tree.
Syntax
func diameter(root *node) int{…}
The diameter() function is used to find the diameter of a tree. It takes pointer to the root node as its argument.
Algorithm
Step 1 − First, we need to import the fmt package.
Step 2 − Now, create a struct of a single node of the tree named, node. It contains three fields, one is to hold integer data value of node while second and third points to the left and right node.
Step 3 − Define the function, new() to initialize a new node.
Step 4 − Now, create a diameter() function that takes a root node as input and returns the diameter of the tree rooted at that node.
Step 5 − The diameter of a tree is the number of nodes on the longest path between any two leaves in the tree.
Step 6 − Return 0, if the root node is nil.
Step 7 − Otherwise, calculate the height of the left and right subtrees using the height function and the diameters of the left and right subtrees recursively using the diameter function.
Step 8 − The diameter of the tree rooted at the current node is the maximum of the sum of the heights of the left and right subtrees plus one, and the diameters of the left and right subtrees.
Step 9 − Now, create a function named height() that takes a root node as input and returns the height of the tree rooted at that node.
Step 10 − Return 0, if the root node is nil. Otherwise, compute the heights of the left and right subtrees recursively and return the maximum of the two heights plus one.
Step 11 − Define max() function to return the maximum of two integers.
Step 12 − Start the main() function. Inside the main() function, call new() function to add nodes to the binary tree.
Step 13 − Now, call the diameter() function to find the diameter of the tree.
Step 14 − Further, the resultant diameter of the tree is printed on the screen by using the fmt.Println() function.
Example 1
In this example, we will define a diameter() function using recursive method that is used to find the diameter of a tree.
package main
import "fmt"
type node struct {
left *node
right *node
data int
}
func new(data int) *node {
return &node{nil, nil, data}
}
func diameter(root *node) int {
if root == nil {
return 0
}
leftH := height(root.left)
rightH := height(root.right)
leftD := diameter(root.left)
rightD := diameter(root.right)
return max(leftH+rightH+1, max(leftD, rightD))
}
func height(root *node) int {
if root == nil {
return 0
}
return 1 + max(height(root.left), height(root.right))
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func main() {
root := new(4)
root.left = new(3)
root.right = new(2)
root.left.left = new(1)
root.left.right = new(5)
fmt.Println("Diameter of the tree is: ", diameter(root))
}
Output
Diameter of the tree is: 4
Example 2
In this example, we will define a diameter() function using iterative method that is used to find the diameter of a tree.
package main
import (
"fmt"
)
type TreeNode struct {
val int
left, right *TreeNode
}
func diameter(root *TreeNode) int {
if root == nil {
return 0
}
stack := []*TreeNode{root}
visited := make(map[*TreeNode]bool)
maxDiameters := make(map[*TreeNode]int)
maxDiameter := 0
for len(stack) > 0 {
node := stack[len(stack)-1]
stack = stack[:len(stack)-1]
visited[node] = true
leftDiameter := 0
rightDiameter := 0
if node.left != nil {
if _, ok := visited[node.left]; !ok {
stack = append(stack, node.left)
}
leftDiameter = maxDiameters[node.left] + 1
}
if node.right != nil {
if _, ok := visited[node.right]; !ok {
stack = append(stack, node.right)
}
rightDiameter = maxDiameters[node.right] + 1
}
maxDiameter = max(maxDiameter, leftDiameter+rightDiameter)
maxDiameters[node] = max(leftDiameter, rightDiameter)
}
return maxDiameter
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
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}
root.left.left.left = &TreeNode{val: 6}
root.left.left.right = &TreeNode{val: 7}
root.left.left.right.left = &TreeNode{val: 8}
root.left.left.right.left.right = &TreeNode{val: 9}
diameter := diameter(root)
fmt.Printf("The diameter of the tree is: %d.\n", diameter)
}
Output
The diameter of the tree is: 2
Conclusion
We have successfully compiled and executed a go language program to we are going to find the diameter of a tree by using recursion and iterative methodalong with two examples. In the first example, we have used the recursive method and in the second example, we have used the iterative method.
145 Views
