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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Postorder Traversal on a Simple Binary Tree

What is the output of the postorder traversal (Left, Right, Root) for the given binary tree?

DSA Go

package main

import "fmt"

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

func postorder(root *Node, result *[]int) {
    if root == nil {
        return
    }
    postorder(root.Left, result)
    postorder(root.Right, result)
    *result = append(*result, root.Val)
}

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

    var result []int
    postorder(root, &result)
    fmt.Println(result)
}

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

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

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

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

💡 Hint

Remember postorder means visit left subtree, then right subtree, then the root node.

In postorder traversal, we first visit the left child nodes, then the right child nodes, and finally the root node. For this tree, the order is 4 (leftmost leaf), 5 (right child of 2), 2 (left child of root), 3 (right child of root), and finally 1 (root).

🧠 Conceptual

intermediate

Understanding Postorder Traversal Steps

Which of the following best describes the order of visiting nodes in postorder traversal?

A Left, Right, Root

B Root, Left, Right

C Right, Left, Root

D Left, Root, Right

💡 Hint

Postorder traversal always visits the root last.

Postorder traversal visits the left subtree first, then the right subtree, and finally the root node.

🔧 Debug

advanced

Identify the Bug in Postorder Traversal Implementation

What error will this code produce when performing postorder traversal?

DSA Go

package main

import "fmt"

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

func postorder(root *Node, result *[]int) {
    if root == nil {
        return
    }
    postorder(root.Right, result)
    postorder(root.Left, result)
    *result = append(*result, root.Val)
}

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

    var result []int
    postorder(root, &result)
    fmt.Println(result)
}

A Output: [3, 2, 1] but order is incorrect for postorder

B Output: [3, 2, 1]

C Output: [2, 3, 1]

D Runtime error: nil pointer dereference

💡 Hint

Check the order of recursive calls for left and right children.

The code visits the right subtree first, then the left subtree, then the root. This reverses the left and right order, so the output is not a correct postorder traversal.

🚀 Application

advanced

Postorder Traversal Output for Unbalanced Tree

Given the following unbalanced binary tree, what is the postorder traversal output?

DSA Go

package main

import "fmt"

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

func postorder(root *Node, result *[]int) {
    if root == nil {
        return
    }
    postorder(root.Left, result)
    postorder(root.Right, result)
    *result = append(*result, root.Val)
}

func main() {
    root := &Node{Val: 10}
    root.Right = &Node{Val: 20}
    root.Right.Left = &Node{Val: 15}
    root.Right.Right = &Node{Val: 25}

    var result []int
    postorder(root, &result)
    fmt.Println(result)
}

A [15, 20, 25, 10]

B [10, 15, 25, 20]

C [15, 25, 20, 10]

D [20, 15, 25, 10]

💡 Hint

Remember to visit left subtree, then right subtree, then root.

The left child of 20 is 15, right child is 25. Postorder visits 15, then 25, then 20, then finally 10.

🧠 Conceptual

expert

Number of Nodes Visited in Postorder Traversal

If a binary tree has 7 nodes, how many nodes will be visited during a complete postorder traversal?

A 6

B 7

C 8

D Depends on the tree structure

💡 Hint

Postorder traversal visits every node exactly once.

Postorder traversal visits every node in the tree exactly once, so the number of nodes visited equals the total number of nodes.