Left Side View of Binary Tree in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Left Side View for a Simple Binary Tree

What is the output of the left side view function when run on the following binary tree?

DSA Go

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

func leftSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    var result []int
    queue := []*TreeNode{root}
    for len(queue) > 0 {
        levelSize := len(queue)
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            if i == 0 {
                result = append(result, node.Val)
            }
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
    }
    return result
}

// Tree structure:
//       1
//      / \
//     2   3
//      \   \
//       5   4

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

output := leftSideView(root)
fmt.Println(output)

A [1 3 5]

B [1 3 4]

C [1 2 4]

D [1 2 5]

💡 Hint

Remember, the left side view shows the first node visible at each level from the left side.

At level 1, node 1 is visible. At level 2, node 2 is the leftmost. At level 3, node 5 is the leftmost visible node.

🧠 Conceptual

intermediate

Understanding Left Side View Node Selection

In the left side view of a binary tree, which nodes are included in the output?

A The leftmost node at each level

B The rightmost node at each level

C All leaf nodes

D All nodes with only one child

💡 Hint

Think about what you see when looking at the tree from the left side.

The left side view includes the first node visible at each level from the left side, which is the leftmost node at each level.

❓ Predict Output

advanced

Output of Left Side View for a Skewed Binary Tree

What is the output of the left side view function when run on this skewed binary tree?

DSA Go

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

func leftSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    var result []int
    queue := []*TreeNode{root}
    for len(queue) > 0 {
        levelSize := len(queue)
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            if i == 0 {
                result = append(result, node.Val)
            }
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
    }
    return result
}

// Tree structure:
// 1
//  \
//   2
//    \
//     3
//      \
//       4

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

output := leftSideView(root)
fmt.Println(output)

A [4]

B [1]

C [1 2 3 4]

D [1 3]

💡 Hint

Even if nodes are only on the right, the left side view includes the first node at each level.

At each level, the only node present is the right child, so it is also the leftmost node at that level.

🔧 Debug

advanced

Identify the Bug in Left Side View Implementation

What error will this code produce when trying to get the left side view of a binary tree?

DSA Go

func leftSideView(root *TreeNode) []int {
    if root == nil {
        return []int{}
    }
    var result []int
    queue := []*TreeNode{root}
    for len(queue) > 0 {
        levelSize := len(queue)
        for i := 0; i < levelSize; i++ {
            node := queue[0]
            queue = queue[1:]
            if i == 0 {
                result = append(result, node.Val)
            }
            if node.Left != nil {
                queue = append(queue, node.Left)
            }
            if node.Right != nil {
                queue = append(queue, node.Right)
            }
        }
    }
    return result
}

A No error, returns correct output

B Index out of range runtime error

C Compilation error due to syntax

D Infinite loop

💡 Hint

Check the loop condition carefully for off-by-one errors.

The inner loop uses i <= levelSize which causes one extra iteration, leading to accessing queue[0] when queue is empty, causing runtime panic.

🚀 Application

expert

Number of Nodes in Left Side View of a Complete Binary Tree

Given a complete binary tree with height h (root at height 1), how many nodes will the left side view contain?

A h

B h - 1

C 2^h - 1

D 2^(h-1)

💡 Hint

The left side view shows one node per level.

In a complete binary tree, the left side view includes exactly one node from each level, so the count equals the height h.