Boundary Traversal of Binary Tree in DSA Go - Build from Scratch

Boundary Traversal of Binary Tree

📖 Scenario: Imagine you have a family tree represented as a binary tree. You want to list all family members who are on the outer edge of the tree, starting from the top ancestor, going down the left side, then the leaves from left to right, and finally up the right side.

🎯 Goal: Build a program in Go that performs a boundary traversal of a binary tree. The program will print the nodes on the boundary in the correct order.

📋 What You'll Learn

Define a binary tree node struct called Node with data, left, and right fields

Create a sample binary tree with exactly these nodes and structure:
Root: 20
Left child of 20: 8
Right child of 20: 22
Left child of 8: 4
Right child of 8: 12
Left child of 12: 10
Right child of 12: 14
Right child of 22: 25

Create a helper variable boundaryNodes as a slice of integers to store the boundary traversal result

Implement functions to add left boundary, leaves, and right boundary nodes to boundaryNodes

Print the boundaryNodes slice as the final output

💡 Why This Matters

🌍 Real World

Boundary traversal helps in graphical rendering, image processing, and understanding the outline of hierarchical data structures.

💼 Career

Understanding tree traversals is essential for software engineers working with data structures, algorithms, and system design.

1

Create the binary tree structure

Define a struct called Node with fields data int, left *Node, and right *Node. Then create the binary tree with root node 20 and the exact structure: left child 8, right child 22, left child of 8 is 4, right child of 8 is 12, left child of 12 is 10, right child of 12 is 14, and right child of 22 is 25.

DSA Go

// Define Node struct and create the binary tree with given nodes
// Your code here

Hint

Start by defining the Node struct. Then create the root node and assign its children exactly as described.

2

Create a slice to hold boundary nodes

Create a variable called boundaryNodes as a slice of integers to store the nodes on the boundary.

DSA Go

package main

import "fmt"

type Node struct {
	data  int
	left  *Node
	right *Node
}

func main() {
	root := &Node{data: 20}
	root.left = &Node{data: 8}
	root.right = &Node{data: 22}
	root.left.left = &Node{data: 4}
	root.left.right = &Node{data: 12}
	root.left.right.left = &Node{data: 10}
	root.left.right.right = &Node{data: 14}
	root.right.right = &Node{data: 25}

	// Create boundaryNodes slice here
	// Your code here
}

Hint

Use boundaryNodes := []int{} to create an empty slice of integers.

3

Implement boundary traversal logic

Write functions addLeftBoundary, addLeaves, and addRightBoundary that take root *Node and boundaryNodes *[]int as parameters. Use these functions to add the left boundary (excluding leaves), all leaf nodes, and the right boundary (excluding leaves) to boundaryNodes. In main, first append root.data to boundaryNodes, then call these functions in order.

DSA Go

package main

import "fmt"

type Node struct {
	data  int
	left  *Node
	right *Node
}

func addLeftBoundary(root *Node, boundaryNodes *[]int) {
	// Your code here
}

func addLeaves(root *Node, boundaryNodes *[]int) {
	// Your code here
}

func addRightBoundary(root *Node, boundaryNodes *[]int) {
	// Your code here
}

func main() {
	root := &Node{data: 20}
	root.left = &Node{data: 8}
	root.right = &Node{data: 22}
	root.left.left = &Node{data: 4}
	root.left.right = &Node{data: 12}
	root.left.right.left = &Node{data: 10}
	root.left.right.right = &Node{data: 14}
	root.right.right = &Node{data: 25}

	boundaryNodes := []int{}

	// Append root data
	// Call addLeftBoundary, addLeaves, addRightBoundary
	// Your code here
}

Hint

Use loops and recursion to add nodes to boundaryNodes. Remember to exclude leaf nodes from left and right boundaries.

4

Print the boundary traversal result

Print the boundaryNodes slice in main to display the boundary traversal of the binary tree.

DSA Go

package main

import "fmt"

type Node struct {
	data  int
	left  *Node
	right *Node
}

func addLeftBoundary(root *Node, boundaryNodes *[]int) {
	curr := root.left
	for curr != nil {
		if curr.left != nil || curr.right != nil {
			*boundaryNodes = append(*boundaryNodes, curr.data)
		}
		if curr.left != nil {
			curr = curr.left
		} else {
			curr = curr.right
		}
	}
}

func addLeaves(root *Node, boundaryNodes *[]int) {
	if root == nil {
		return
	}
	if root.left == nil && root.right == nil {
		*boundaryNodes = append(*boundaryNodes, root.data)
		return
	}
	addLeaves(root.left, boundaryNodes)
	addLeaves(root.right, boundaryNodes)
}

func addRightBoundary(root *Node, boundaryNodes *[]int) {
	curr := root.right
	temp := []int{}
	for curr != nil {
		if curr.left != nil || curr.right != nil {
			temp = append(temp, curr.data)
		}
		if curr.right != nil {
			curr = curr.right
		} else {
			curr = curr.left
		}
	}
	for i := len(temp) - 1; i >= 0; i-- {
		*boundaryNodes = append(*boundaryNodes, temp[i])
	}
}

func main() {
	root := &Node{data: 20}
	root.left = &Node{data: 8}
	root.right = &Node{data: 22}
	root.left.left = &Node{data: 4}
	root.left.right = &Node{data: 12}
	root.left.right.left = &Node{data: 10}
	root.left.right.right = &Node{data: 14}
	root.right.right = &Node{data: 25}

	boundaryNodes := []int{}

	boundaryNodes = append(boundaryNodes, root.data)
	addLeftBoundary(root, &boundaryNodes)
	addLeaves(root, &boundaryNodes)
	addRightBoundary(root, &boundaryNodes)

	// Print the boundaryNodes slice
	// Your code here
}

Hint

Use fmt.Println(boundaryNodes) to print the slice showing the boundary traversal.