Minimum in a Binary Search Tree (original) (raw)

Last Updated : 11 Oct, 2025

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

**Example:

**Input:

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

**Input:

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

Try It Yourself

Table of Content

• [Naive Approach] Using Inorder Traversal - O(n) Time and O(n) Space
• [Better Approach] Using Recursion - O(h) Time and O(h) Space
• [Expected Approach] Using Iterative Way - O(h) Time and O(1) Space

[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 #include 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& 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

`

[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 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

`

[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 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

`