Left Side View of Binary Tree in DSA Go - Build from Scratch

Left Side View of Binary Tree

📖 Scenario: Imagine you have a family tree represented as a binary tree. You want to see only the leftmost family members at each generation level.

🎯 Goal: Build a program that finds the left side view of a binary tree. This means printing the nodes you see when looking at the tree from the left side.

📋 What You'll Learn

Create a binary tree with specific nodes

Use a variable to track the current level during traversal

Implement a function to collect the left side view nodes

Print the left side view nodes in order

💡 Why This Matters

🌍 Real World

Left side view of a binary tree helps visualize hierarchical data from a specific angle, useful in family trees, organizational charts, and UI layouts.

💼 Career

Understanding tree traversal and views is important for software engineers working with hierarchical data structures, UI rendering, and algorithms.

1

Create the binary tree structure and nodes

Define a struct called TreeNode with Val int, Left *TreeNode, and Right *TreeNode. Then create the binary tree with these exact nodes and connections:
root with value 1,
root.Left with value 2,
root.Right with value 3,
root.Left.Left with value 4,
root.Left.Right with value 5.

DSA Go

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

// Create the binary tree nodes and connect them
// Your code here

Hint

Start by defining the TreeNode struct. Then create the root node and assign its left and right children as shown.

2

Add a variable to track the current level

Inside main, create a variable called maxLevel and set it to 0. This will help track the deepest level visited 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 maxLevel variable
    // Your code here
}

Hint

Declare maxLevel as an integer and initialize it to zero inside the main function.

3

Implement the function to get the left side view

Write a function called leftView that takes root *TreeNode, level int, maxLevel *int, and result *[]int. Inside it, if root is nil, return immediately. If level is greater than *maxLevel, append root.Val to *result and update *maxLevel = level. Then recursively call leftView for root.Left and root.Right with level+1.

DSA Go

package main

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

func leftView(root *TreeNode, level int, maxLevel *int, result *[]int) {
    // Your code here
}

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}

    maxLevel := 0
}

Hint

Use recursion to visit nodes. Check if the current level is deeper than maxLevel. If yes, add the node's value to result and update maxLevel. Visit left child first, then right child.

4

Call the function and print the left side view

In main, create a slice called result of type []int. Call leftView(root, 1, &maxLevel, &result). Then print result using fmt.Println(result). Import "fmt" at the top.

DSA Go

package main

import "fmt"

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

func leftView(root *TreeNode, level int, maxLevel *int, result *[]int) {
    if root == nil {
        return
    }
    if level > *maxLevel {
        *result = append(*result, root.Val)
        *maxLevel = level
    }
    leftView(root.Left, level+1, maxLevel, result)
    leftView(root.Right, level+1, maxLevel, result)
}

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}

    maxLevel := 0

    // Create result slice and call leftView
    // Print the result
    // Your code here
}

Hint

Create an empty slice result. Call leftView starting at level 1. Print the result slice to see the left side view.