BST Find Minimum Element in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find minimum element in a BST

What is the output of this Go code that finds the minimum element in a binary search tree?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}
func findMin(root *Node) int {
    current := root
    for current.Left != nil {
        current = current.Left
    }
    return current.Val
}
func main() {
    root := &Node{Val: 10}
    root.Left = &Node{Val: 5}
    root.Right = &Node{Val: 15}
    root.Left.Left = &Node{Val: 2}
    root.Left.Right = &Node{Val: 7}
    fmt.Println(findMin(root))
}

A 10

B 2

C 7

D 5

💡 Hint

The minimum element in a BST is the leftmost node.

The function moves left until it finds the leftmost node, which has the smallest value. Here, that value is 2.

❓ Predict Output

intermediate

Minimum element in a BST with only right children

What will the output be when finding the minimum element in this BST where all nodes only have right children?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}
func findMin(root *Node) int {
    current := root
    for current.Left != nil {
        current = current.Left
    }
    return current.Val
}
func main() {
    root := &Node{Val: 3}
    root.Right = &Node{Val: 6}
    root.Right.Right = &Node{Val: 9}
    fmt.Println(findMin(root))
}

A 9

B 6

C 3

D 0

💡 Hint

If there is no left child, the root is the minimum.

Since no node has a left child, the root node value 3 is the minimum.

🔧 Debug

advanced

Identify the error in this BST minimum finder

What error will this Go code produce when trying to find the minimum element in a BST?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}
func findMin(root *Node) int {
    current := root
    for current != nil {
        current = current.Left
    }
    return current.Val
}
func main() {
    root := &Node{Val: 8}
    root.Left = &Node{Val: 3}
    root.Left.Left = &Node{Val: 1}
    fmt.Println(findMin(root))
}

A 1

B 8

C 0

D runtime error: invalid memory address or nil pointer dereference

💡 Hint

Check what happens after the loop ends.

The loop continues until current is nil, then tries to access current.Val causing a nil pointer dereference.

🧠 Conceptual

advanced

Why does the minimum element lie in the left subtree in a BST?

Which option best explains why the minimum element in a binary search tree is always found by going left until no more left child exists?

A Because in a BST, left children are always smaller than their parent nodes, so the leftmost node is the smallest.

B Because right children are always smaller than their parent nodes, so the minimum is on the right.

C Because the root node always contains the minimum value in a BST.

D Because the minimum value is always stored in the rightmost leaf node.

💡 Hint

Recall the BST property about left and right children values.

By definition, in a BST, left children have smaller values than their parents, so the smallest value is found by going left as far as possible.

❓ Predict Output

expert

Output of recursive minimum finder in BST

What is the output of this recursive Go function that finds the minimum element in a BST?

DSA Go

package main
import "fmt"
type Node struct {
    Val   int
    Left  *Node
    Right *Node
}
func findMinRecursive(root *Node) int {
    if root.Left == nil {
        return root.Val
    }
    return findMinRecursive(root.Left)
}
func main() {
    root := &Node{Val: 20}
    root.Left = &Node{Val: 10}
    root.Left.Left = &Node{Val: 5}
    root.Left.Left.Left = &Node{Val: 2}
    root.Right = &Node{Val: 30}
    fmt.Println(findMinRecursive(root))
}

A 2

B 5

C 10

D 20

💡 Hint

The function calls itself on the left child until no left child exists.

The recursion goes down the left children until it reaches the leftmost node with value 2, which it returns.