Tree Traversal Inorder Left Root Right in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of inorder traversal on this binary tree?

Given the binary tree below, what is the inorder traversal output?

Tree structure:

    2
   / \
  1   3

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}

func inorder(root *Node) {
    if root == nil {
        return
    }
    inorder(root.Left)
    fmt.Print(root.Val, " ")
    inorder(root.Right)
}

func main() {
    root := &Node{Val: 2}
    root.Left = &Node{Val: 1}
    root.Right = &Node{Val: 3}
    inorder(root)
}

A 1 2 3

B 2 1 3

C 3 2 1

D 1 3 2

💡 Hint

Inorder traversal visits left child, then root, then right child.

Inorder traversal visits nodes in the order: left subtree, root, right subtree. For this tree, it visits 1, then 2, then 3.

❓ Predict Output

intermediate

What is the inorder traversal output of this tree?

Consider the binary tree:

      4
     / \
    2   5
   / \
  1   3

What is the output of inorder traversal?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}

func inorder(root *Node) {
    if root == nil {
        return
    }
    inorder(root.Left)
    fmt.Print(root.Val, " ")
    inorder(root.Right)
}

func main() {
    root := &Node{Val: 4}
    root.Left = &Node{Val: 2}
    root.Right = &Node{Val: 5}
    root.Left.Left = &Node{Val: 1}
    root.Left.Right = &Node{Val: 3}
    inorder(root)
}

A 4 2 1 3 5

B 1 2 3 4 5

C 2 1 3 4 5

D 1 3 2 4 5

💡 Hint

Remember inorder is left, root, right recursively.

Inorder traversal visits nodes in ascending order for this BST: 1, 2, 3, 4, 5.

🔧 Debug

advanced

What error does this inorder traversal code produce?

Analyze the following Go code for inorder traversal. What error will it produce when run?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}

func inorder(root *Node) {
    if root == nil {
        return
    }
    inorder(root.Left)
    fmt.Print(root.Val)
    inorder(root.Right)
}

func main() {
    var root *Node
    inorder(root.Left)
}

A runtime error: invalid memory address or nil pointer dereference

B compilation error: undefined variable root

C no output, program runs successfully

D compilation error: missing return statement

💡 Hint

Check what happens when you access a field of a nil pointer.

root is nil, so root.Left causes a runtime panic due to nil pointer dereference.

🧠 Conceptual

advanced

How many nodes are visited in inorder traversal of this tree?

Given the binary tree:

      10
     /  \
    5    15
   /    /  \
  3    12   20

How many nodes will inorder traversal visit?

A 5

B 7

C 4

D 6

💡 Hint

Count all nodes in the tree.

There are 6 nodes: 10, 5, 15, 3, 12, 20. Inorder traversal visits all 6 nodes.

🚀 Application

expert

What is the inorder traversal output after inserting 7 into this BST?

Given the BST:

      5
     / \
    3   8
   /   / \
  2   6   9

After inserting 7, what is the inorder traversal output?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}

func insert(root *Node, val int) *Node {
    if root == nil {
        return &Node{Val: val}
    }
    if val < root.Val {
        root.Left = insert(root.Left, val)
    } else {
        root.Right = insert(root.Right, val)
    }
    return root
}

func inorder(root *Node) {
    if root == nil {
        return
    }
    inorder(root.Left)
    fmt.Print(root.Val, " ")
    inorder(root.Right)
}

func main() {
    root := &Node{Val: 5}
    root.Left = &Node{Val: 3}
    root.Right = &Node{Val: 8}
    root.Left.Left = &Node{Val: 2}
    root.Right.Left = &Node{Val: 6}
    root.Right.Right = &Node{Val: 9}
    root = insert(root, 7)
    inorder(root)
}

A 2 3 5 7 6 8 9

B 2 3 5 6 8 7 9

C 2 3 5 6 7 8 9

D 2 3 5 6 8 9 7

💡 Hint

Inorder traversal of BST prints nodes in ascending order.

After inserting 7, the inorder traversal visits nodes in sorted order: 2, 3, 5, 6, 7, 8, 9.