BST Find Minimum Element in DSA Go - Build from Scratch

BST Find Minimum Element

📖 Scenario: You are working with a Binary Search Tree (BST) that stores numbers. You want to find the smallest number in the tree. This is useful when you want to quickly find the minimum value in a sorted structure.

🎯 Goal: Build a simple BST with a few nodes, then write code to find and print the minimum element in the BST.

📋 What You'll Learn

Create a BST node structure with integer values

Insert nodes to form a BST with these exact values: 15, 10, 20, 8, 12

Write a function to find the minimum element in the BST

Print the minimum element found

💡 Why This Matters

🌍 Real World

Finding minimum or maximum values quickly is important in many applications like databases, scheduling, and priority queues.

💼 Career

Understanding BST operations is fundamental for software engineers working with data structures, algorithms, and performance optimization.

1

Create BST Node Structure and Insert Nodes

Create a struct called Node with an int field called value and two pointers called left and right of type *Node. Then create a variable called root and assign it a pointer to a Node with value 15. Next, manually create and link nodes with values 10, 20, 8, and 12 to form the BST exactly as follows: 15 is root, 10 is left child of 15, 20 is right child of 15, 8 is left child of 10, and 12 is right child of 10.

DSA Go

// Your code here

Hint

Define the Node struct first. Then create root and assign child nodes by setting root.left, root.right, and so on.

2

Create a Function to Find Minimum Element

Create a function called findMin that takes a pointer to Node called root and returns an int. Inside the function, use a variable called current to traverse the tree starting from root. Move current to its left child repeatedly until current.left is nil. Then return current.value as the minimum element.

DSA Go

package main

type Node struct {
    value int
    left  *Node
    right *Node
}

func main() {
    root := &Node{value: 15}
    root.left = &Node{value: 10}
    root.right = &Node{value: 20}
    root.left.left = &Node{value: 8}
    root.left.right = &Node{value: 12}
}

// Create function findMin with parameter root *Node returning int
// Your code here

Hint

Use a for loop to keep moving left until no more left child exists.

3

Call findMin Function in main

Inside the main function, call the findMin function with root as argument and assign the result to a variable called minValue.

DSA Go

package main

type Node struct {
    value int
    left  *Node
    right *Node
}

func findMin(root *Node) int {
    current := root
    for current.left != nil {
        current = current.left
    }
    return current.value
}

func main() {
    root := &Node{value: 15}
    root.left = &Node{value: 10}
    root.right = &Node{value: 20}
    root.left.left = &Node{value: 8}
    root.left.right = &Node{value: 12}

    // Call findMin with root and assign to minValue
    // Your code here
}

Hint

Assign the result of findMin(root) to minValue.

4

Print the Minimum Element

Add a fmt.Println statement in main to print the text "Minimum element:" followed by the value of minValue.

DSA Go

package main

import "fmt"

type Node struct {
    value int
    left  *Node
    right *Node
}

func findMin(root *Node) int {
    current := root
    for current.left != nil {
        current = current.left
    }
    return current.value
}

func main() {
    root := &Node{value: 15}
    root.left = &Node{value: 10}
    root.right = &Node{value: 20}
    root.left.left = &Node{value: 8}
    root.left.right = &Node{value: 12}

    minValue := findMin(root)

    // Print "Minimum element:" and minValue
    // Your code here
}

Hint

Use fmt.Println("Minimum element:", minValue) to print the result.