Minimum in a Binary Search Tree

Last Updated : 11 Oct, 2025

Given the root of a Binary Search Tree (BST), find the minimum value present in the tree.

Example: 

Input:

ex-1

Output: 1
Explanation: The minimum element in the given BST is 1.

Input:

ex-2

Output: 2
Explanation: The minimum element in the given BST is 2

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Using Inorder Traversal - O(n) Time and O(n) Space

The idea is to use the property of BST which says inorder traversal of a binary search tree always returns the value of nodes in sorted order. So the 1st value in the sorted vector will be the minimum value which is the answer.

C++ 
//Driver Code Starts
#include <iostream>
#include<vector>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node *left, *right;

    Node(int val) {
        data = val;
        left = right = nullptr;
    }
};
//Driver Code Ends


// Performs inorder traversal of BST 
// and stores values in sorted order
void inorder(Node* root, vector<int>& sortedInorder) {
  
    // Base Case
    if (root == nullptr) return;

    // Traverse left subtree
    inorder(root->left, sortedInorder);

    sortedInorder.push_back(root->data);

    // Traverse right subtree
    inorder(root->right, sortedInorder);
}

// Returns the minimum value in a BST
int minValue(Node* root) {
    if (root == nullptr) {
        return -1;
    }
    
    vector<int> sortedInorder;
    
    // Get all BST values in sorted order
    inorder(root, sortedInorder);
    
    return sortedInorder[0];
}


//Driver Code Starts
int main() {

    // Create BST
    //        5
    //       / \
    //      4   6
    //     /     \
    //    3       7
    //   / 
    //  1
    Node* root = new Node(5);
    root->left = new Node(4);
    root->right = new Node(6);
    root->left->left = new Node(3);
    root->right->right = new Node(7);
    root->left->left->left = new Node(1);

    cout << minValue(root) << "
";

    return 0;
}

//Driver Code Ends
C 
//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define MAX_SIZE 100000

// Node structure
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
}; 

struct Node* createNode(int val) {
    struct Node* node
      = (struct Node*)malloc(sizeof(struct Node));
    node->data = val;
    node->left = node->right = NULL;
//Driver Code Ends

    return node;
}

// Performs inorder traversal of BST and stores values in sorted order
void inorder(struct Node* root, int *sortedInorder, int *index) {
    if (root == NULL) return;

    // Traverse left subtree
    inorder(root->left, sortedInorder, index);

    sortedInorder[(*index)++] = root->data;

    // Traverse right subtree
    inorder(root->right, sortedInorder, index);
}

// Returns the minimum value in a BST
int minValue(struct Node* root) {
    if (root == NULL) return -1;
    
    // Array to hold inorder elements
    int sortedInorder[MAX_SIZE];  
    int index = 0;

    // Get all BST values in sorted order
    inorder(root, sortedInorder, &index);

    return sortedInorder[0];

//Driver Code Starts
}

int main() {

    // Create BST
    //        5
    //       / \
    //      4   6
    //     /     \
    //    3       7
    //   /
    //  1
    struct Node* root = createNode(5);
    root->left = createNode(4);
    root->right = createNode(6);
    root->left->left = createNode(3);
    root->right->right = createNode(7);
    root->left->left->left = createNode(1);

    printf("%d
", minValue(root));

    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
import java.util.ArrayList;

// Node structure
class Node {
    int data;
    Node left, right;

    Node(int val) {
        data = val;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends


    // Performs inorder traversal of BST 
    // and stores values in sorted order
    static void inorder(Node root, ArrayList<Integer> sortedInorder) {
        if (root == null) return;
    
        // Traverse left subtree
        inorder(root.left, sortedInorder);
    
        sortedInorder.add(root.data);
    
        // Traverse right subtree
        inorder(root.right, sortedInorder);
    }
    
    // Returns the minimum value in a BST
    static int minValue(Node root) {
        if (root == null) return -1;
    
        ArrayList<Integer> sortedInorder = new ArrayList<>();
    
        // Get all BST values in sorted order
        inorder(root, sortedInorder);
    
        return sortedInorder.get(0);
    }


//Driver Code Starts
    public static void main(String[] args) {

        // Create BST
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        System.out.println(minValue(root));
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
#Driver Code Ends


# Performs inorder traversal of BST
# and stores values in sorted order
def inorder(root, sortedInorder):
    if root is None:
        return

    # Traverse left subtree
    inorder(root.left, sortedInorder)

    sortedInorder.append(root.data)

    # Traverse right subtree
    inorder(root.right, sortedInorder)

# Returns the minimum value in a BST
def minValue(root):
    if root is None:
        return -1

    sortedInorder = []

    # Get all BST values in sorted order
    inorder(root, sortedInorder)

    return sortedInorder[0]


#Driver Code Starts
if __name__ == "__main__":
  
    # Create BST
    #        5
    #       / \
    #      4   6
    #     /     \
    #    3       7
    #   /
    #  1
    root = Node(5)
    root.left = Node(4)
    root.right = Node(6)
    root.left.left = Node(3)
    root.right.right = Node(7)
    root.left.left.left = Node(1)

    print(minValue(root))

#Driver Code Ends
C# 
//Driver Code Starts
using System;
using System.Collections.Generic;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int val) {
        data = val;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends


    // Performs inorder traversal of BST
    // and stores values in sorted order
    static void inorder(Node root, List<int> sortedInorder) {
        if (root == null) return;
    
        // Traverse left subtree
        inorder(root.left, sortedInorder);
    
        sortedInorder.Add(root.data);
    
        // Traverse right subtree
        inorder(root.right, sortedInorder);
    }
    
    // Returns the minimum value in a BST
    static int minValue(Node root) {
        if (root == null) return -1;
    
        List<int> sortedInorder = new List<int>();
    
        // Get all BST values in sorted order
        inorder(root, sortedInorder);
    
        return sortedInorder[0];
    }


//Driver Code Starts
    static void Main(string[] args) {

        // Create BST
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        Console.WriteLine(minValue(root));
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


// Performs inorder traversal of BST
// and stores values in sorted order
function inorder(root, sortedInorder) {
    if (root === null) return;

    // Traverse left subtree
    inorder(root.left, sortedInorder);

    sortedInorder.push(root.data);

    // Traverse right subtree
    inorder(root.right, sortedInorder);
}

// Returns the minimum value in a BST
function minValue(root) {
    if (root === null) return -1;

    const sortedInorder = [];

    // Get all BST values in sorted order
    inorder(root, sortedInorder);

    return sortedInorder[0];
}


//Driver Code Starts
// Driver Code

// Create BST
//        5
//       / \
//      4   6
//     /     \
//    3       7
//   /
//  1
let root = new Node(5);
root.left = new Node(4);
root.right = new Node(6);
root.left.left = new Node(3);
root.right.right = new Node(7);
root.left.left.left = new Node(1);

console.log(minValue(root));

//Driver Code Ends

Output
1

[Better Approach] Using Recursion - O(h) Time and O(h) Space

The idea is to start from the root and keep traversing the left child recursively (or iteratively) until a node has no left child. This node contains the minimum value in the BST.

C++ 
//Driver Code Starts
#include <iostream>
using namespace std;

// Node structure
class Node {
public:
    int data;
    Node *left, *right;
    Node(int x) {
        data = x;
        left = right = nullptr;
    }
};
//Driver Code Ends


int minValue(Node* root) {
    
    // If left child is null, root is minimum
    if (root->left == nullptr) return root->data;
    
    // Recurse on left child
    return minValue(root->left);
}


//Driver Code Starts
int main() {
    // Create BST
    //        5
    //       / \
    //      4   6
    //     /     \
    //    3       7
    //   / 
    //  1
    Node* root = new Node(5);
    root->left = new Node(4);
    root->right = new Node(6);
    root->left->left = new Node(3);
    root->right->right = new Node(7);
    root->left->left->left = new Node(1);

    cout << minValue(root) << endl;
}

//Driver Code Ends
Java 
//Driver Code Starts
class Node {
    int data;
    Node left, right;
    Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

    
    static int minValue(Node root) {
        
        // If left child is null, root is minimum
        if (root.left == null) return root.data;
        
        // Recurse on left child
        return minValue(root.left);
    }
    

//Driver Code Starts
    public static void main(String[] args) {
        // Create BST
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        System.out.println(minValue(root));
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
#Driver Code Ends


def minValue(root):
    
    # If left child is null, root is minimum
    if root.left is None:
        return root.data
        
    # Recurse on left child
    return minValue(root.left)


#Driver Code Starts

if __name__ == "__main__":
    # Create BST
    #        5
    #       / \
    #      4   6
    #     /     \
    #    3       7
    #   /
    #  1
    root = Node(5)
    root.left = Node(4)
    root.right = Node(6)
    root.left.left = Node(3)
    root.right.right = Node(7)
    root.left.left.left = Node(1)
    
    print(minValue(root))

#Driver Code Ends
C# 
//Driver Code Starts
using System;

// Node structure
class Node {
    public int data;
    public Node left, right;
    public Node(int x) {
        data = x;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends

    
    static int minValue(Node root) {
        
        // If left child is null, root is minimum
        if (root.left == null) return root.data;
        
        // Recurse on left child
        return minValue(root.left);
    }


//Driver Code Starts
    static void Main() {
        // Create BST
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        Console.WriteLine(minValue(root));
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


function minValue(root) {
    
    // If left child is null, root is minimum
    if (root.left === null) return root.data;
    
    // Recurse on left child
    return minValue(root.left);
}


//Driver Code Starts
// Create BST
//        5
//       / \
//      4   6
//     /     \
//    3       7
//   /
//  1
let root = new Node(5);
root.left = new Node(4);
root.right = new Node(6);
root.left.left = new Node(3);
root.right.right = new Node(7);
root.left.left.left = new Node(1);

console.log(minValue(root));
//Driver Code Ends

Output
1

[Expected Approach] Using Iterative Way - O(h) Time and O(1) Space

The idea is that in a Binary Search Tree (BST), the left child of a node is always smaller than the root. This ensures that the node whose left pointer is NULL must hold the minimum value in the tree. The leftmost node will always contain the smallest element.

C++ 
//Driver Code Starts
#include <iostream>
using namespace std;

// Node structure
struct Node {
    int data;
    Node *left, *right;

    Node(int val) {
        data = val;
        left = right = nullptr;
    }
};
//Driver Code Ends


int minValue(Node* root) {
    if (root == nullptr) {
        return -1;
    }

    Node* curr = root;

    // leftmost node is minimum so we move in BST till
    // left node is not nullptr
    while (curr->left != nullptr) {
        curr = curr->left;
    }

    // returning the data at the leftmost node
    return curr->data;
}


//Driver Code Starts
int main() {

    // Representation of input binary search tree
    //        5
    //       / \
    //      4   6
    //     /     \
    //    3       7
    //   / 
    //  1
    Node* root = new Node(5);
    root->left = new Node(4);
    root->right = new Node(6);
    root->left->left = new Node(3);
    root->right->right = new Node(7);
    root->left->left->left = new Node(1);

    cout << minValue(root) << "
";

    return 0;
}

//Driver Code Ends
C 
//Driver Code Starts
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

// Node structure
struct Node {
    int data;
    struct Node* left;
    struct Node* right;
};

struct Node* createNode(int val) {
    struct Node* node 
            = (struct Node*)malloc(sizeof(struct Node));
    node->data = val;
    node->left = node->right = NULL;
    return node;
}
//Driver Code Ends


int minValue(struct Node* root) {
    if (root == NULL) {
        return -1;
    }

    struct Node* curr = root;

    // leftmost node is minimum, so move 
    // till left is not NULL
    while (curr->left != NULL) {
        curr = curr->left;
    }

    // returning the data at the leftmost node
    return curr->data;
}


//Driver Code Starts
int main() {

    // Representation of input binary search tree
    //        5
    //       / \
    //      4   6
    //     /     \
    //    3       7
    //   /
    //  1
    struct Node* root = createNode(5);
    root->left = createNode(4);
    root->right = createNode(6);
    root->left->left = createNode(3);
    root->right->right = createNode(7);
    root->left->left->left = createNode(1);

    printf("%d
", minValue(root));

    return 0;
}

//Driver Code Ends
Java 
//Driver Code Starts
// Node structure
class Node {
    int data;
    Node left, right;

    Node(int val) {
        data = val;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends


    static int minValue(Node root) {
        if (root == null) {
            return -1;
        }

        Node curr = root;

        // leftmost node is minimum, so move till 
        // left is not null
        while (curr.left != null) {
            curr = curr.left;
        }

        // returning the data at the leftmost node
        return curr.data;
    }


//Driver Code Starts
    public static void main(String[] args) {

        // Representation of input binary search tree
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        System.out.println(minValue(root));
    }
}

//Driver Code Ends
Python 
#Driver Code Starts
# Node structure
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

#Driver Code Ends


def minValue(root):
    if root is None:
        return -1

    curr = root

    # leftmost node is minimum, so move 
    # till left is not None
    while curr.left is not None:
        curr = curr.left

    # returning the data at the leftmost node
    return curr.data


#Driver Code Starts
if __name__ == "__main__":
  
    # Representation of input binary search tree
    #        5
    #       / \
    #      4   6
    #     /     \
    #    3       7
    #   /
    #  1
    root = Node(5)
    root.left = Node(4)
    root.right = Node(6)
    root.left.left = Node(3)
    root.right.right = Node(7)
    root.left.left.left = Node(1)

    print(minValue(root))

#Driver Code Ends
C# 
//Driver Code Starts
using System;
using System.Collections.Generic;

// Node structure
class Node {
    public int data;
    public Node left, right;

    public Node(int val) {
        data = val;
        left = right = null;
    }
}

class GFG {
//Driver Code Ends


    static int minValue(Node root) {
        if (root == null) {
            return -1;
        }

        Node curr = root;

        // leftmost node is minimum, so move 
        // till left is not null
        while (curr.left != null) {
            curr = curr.left;
        }

        // returning the data at the leftmost node
        return curr.data;
    }


//Driver Code Starts
    static void Main(string[] args) {

        // Representation of input binary search tree
        //        5
        //       / \
        //      4   6
        //     /     \
        //    3       7
        //   /
        //  1
        Node root = new Node(5);
        root.left = new Node(4);
        root.right = new Node(6);
        root.left.left = new Node(3);
        root.right.right = new Node(7);
        root.left.left.left = new Node(1);

        Console.WriteLine(minValue(root));
    }
}

//Driver Code Ends
JavaScript 
//Driver Code Starts
// Node structure
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends


function minValue(root) {
    if (root === null) {
        return -1;
    }

    let curr = root;

    // leftmost node is minimum, so move till 
    // left is not null
    while (curr.left !== null) {
        curr = curr.left;
    }

    // returning the data at the leftmost node
    return curr.data;
}


//Driver Code Starts
// Driver Code

// Representation of input binary search tree
//        5
//       / \
//      4   6
//     /     \
//    3       7
//   /
//  1
let root = new Node(5);
root.left = new Node(4);
root.right = new Node(6);
root.left.left = new Node(3);
root.right.right = new Node(7);
root.left.left.left = new Node(1);

// Output the minimum value in the BST
console.log(minValue(root));

//Driver Code Ends

Output
1


Comment
Article Tags:
Tree
Binary Search Tree
DSA
Microsoft

Explore