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.

Practice

1. What does the "Left Side View" of a binary tree represent?

easy

A. All leaf nodes of the tree

B. Nodes visible when the tree is viewed from the right side

C. Nodes visible when the tree is viewed from the left side

D. Nodes at the deepest level only

Solution

1. Step 1: Understand the view perspective

   The left side view shows nodes visible when looking at the tree from the left side.

2. Step 2: Identify visible nodes

   Only the first node encountered at each level from the left is visible.

3. Final Answer:

   Nodes visible when the tree is viewed from the left side -> Option C

4. Quick Check:

   Left side view = nodes seen from left [OK]

Hint: Think of standing on the left side and seeing nodes [OK]

Common Mistakes:

• Confusing left side view with right side view
• Including all leaf nodes instead of first nodes per level
• Thinking it shows deepest nodes only

2. Which Go code snippet correctly declares a binary tree node struct for use in left side view traversal?

easy

A. type TreeNode struct { Value int; LeftNode, RightNode *TreeNode }

B. type TreeNode struct { Val int; Left, Right *TreeNode }

C. struct TreeNode { int Val; TreeNode* Left; TreeNode* Right; }

D. class TreeNode { int val; TreeNode left; TreeNode right; }

Solution

1. Step 1: Identify Go struct syntax

   Go uses 'type Name struct { fields }' with field types after names.

2. Step 2: Check pointer usage for child nodes

   Child nodes are pointers to TreeNode, written as '*TreeNode'.

3. Final Answer:

   type TreeNode struct { Val int; Left, Right *TreeNode } -> Option B

4. Quick Check:

   Go struct with pointers = type TreeNode struct { Val int; Left, Right *TreeNode } [OK]

Hint: Go structs use 'type' and pointers with * for child nodes [OK]

Common Mistakes:

• Using C or Java syntax instead of Go
• Missing pointer * for child nodes
• Incorrect field names or order

3. What is the left side view output of this binary tree?

    1
   / \
  2   3
   \   \
    4   5

medium

A. [1, 2, 4]

B. [1, 3, 5]

C. [1, 2, 3]

D. [1, 4, 5]

Solution

1. Step 1: Identify nodes visible from left at each level

   Level 1: Node 1; Level 2: Node 2 (left child); Level 3: Node 4 (right child of 2, visible from left).

2. Step 2: Collect nodes in order

   Left side view nodes are [1, 2, 4].

3. Final Answer:

   [1, 2, 4] -> Option A

4. Quick Check:

   Left side nodes = [1, 2, 4] [OK]

Hint: Pick first node at each level from left side [OK]

Common Mistakes:

• Choosing right child nodes instead of left
• Including nodes not visible from left
• Confusing level order

4. Given this Go function to get left side view, what is the bug?

func leftSideView(root *TreeNode) []int {
    var result []int
    var dfs func(node *TreeNode, level int)
    dfs = func(node *TreeNode, level int) {
        if node == nil {
            return
        }
        if level == len(result) {
            result = append(result, node.Val)
        }
        dfs(node.Right, level+1)
        dfs(node.Left, level+1)
    }
    dfs(root, 0)
    return result
}

medium

A. Traverse right child before left, so left side nodes missed

B. Missing base case for nil node

C. Appending node.Val at wrong condition

D. Not initializing result slice

Solution

1. Step 1: Analyze traversal order

   The function visits right child before left child, so right nodes are added first.

2. Step 2: Understand left side view logic

   To get left side view, left child must be visited before right child to capture leftmost nodes first.

3. Final Answer:

   Traverse right child before left, so left side nodes missed -> Option A

4. Quick Check:

   Left side view needs left-first traversal [OK]

Hint: Visit left child before right for left side view [OK]

Common Mistakes:

• Swapping left and right traversal order
• Ignoring base case (though present here)
• Appending values incorrectly

5. You want to find the left side view of a binary tree but only have access to its level order traversal array with nulls for missing nodes:

[1, 2, 3, null, 4, null, 5]

Which approach correctly finds the left side view?

hard

A. Sort the array and pick first element of each value group

B. Traverse the array directly and pick all non-null nodes

C. Use DFS on array indices to find leftmost nodes

D. Rebuild the tree from level order, then do BFS picking first node at each level

Solution

1. Step 1: Understand input format

   Level order array with nulls represents tree nodes level by level, including missing nodes.

2. Step 2: Rebuild tree structure

   Reconstruct the binary tree from the array to restore parent-child links.

3. Step 3: Perform BFS for left side view

   Use breadth-first search and pick the first node at each level for left side view.

4. Final Answer:

   Rebuild the tree from level order, then do BFS picking first node at each level -> Option D

5. Quick Check:

   Rebuild + BFS first node per level = left side view [OK]

Hint: Rebuild tree first, then BFS for leftmost nodes per level [OK]

Common Mistakes:

• Trying to pick nodes directly from array without tree structure
• Using DFS on array indices which is invalid
• Sorting array which loses tree structure