Find the node with minimum value in a Binary Search Tree using recursion
Last Updated :
25 May, 2022
Given a Binary Search Tree, the task is to find the node with minimum value.
Examples:
Input:
Output: 4
Approach: Just traverse the node from root to left recursively until left is NULL. The node whose left is NULL is the node with the minimum value.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
struct node* left;
struct node* right;
};
struct node* newNode( int data)
{
struct node* node = ( struct node*)
malloc ( sizeof ( struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return (node);
}
struct node* insert( struct node* node, int data)
{
if (node == NULL)
return (newNode(data));
else {
if (data <= node->data)
node->left = insert(node->left, data);
else
node->right = insert(node->right, data);
return node;
}
}
int minValue( struct node* node)
{
if (node->left == NULL)
return node->data;
return minValue(node->left);
}
int main()
{
struct node* root = NULL;
root = insert(root, 4);
insert(root, 2);
insert(root, 1);
insert(root, 3);
insert(root, 6);
insert(root, 5);
cout << minValue(root);
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node left;
Node right;
};
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
static Node insert(Node node, int data)
{
if (node == null )
return (newNode(data));
else
{
if (data <= node.data)
node.left = insert(node.left, data);
else
node.right = insert(node.right, data);
return node;
}
}
static int minValue(Node node)
{
if (node.left == null )
return node.data;
return minValue(node.left);
}
public static void main(String args[])
{
Node root = null ;
root = insert(root, 4 );
insert(root, 2 );
insert(root, 1 );
insert(root, 3 );
insert(root, 6 );
insert(root, 5 );
System.out.println(minValue(root));
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def insert(node, data):
if node is None :
return Node(data)
else :
if data < = node.data:
node.left = insert(node.left, data)
else :
node.right = insert(node.right, data)
return node
def minValue(node):
if node.left = = None :
return node.data
return minValue(node.left)
if __name__ = = "__main__" :
root = None
root = insert(root, 4 )
insert(root, 2 )
insert(root, 1 )
insert(root, 3 )
insert(root, 6 )
insert(root, 5 )
print (minValue(root))
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node left;
public Node right;
};
static Node newNode( int data)
{
Node node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
static Node insert(Node node, int data)
{
if (node == null )
return (newNode(data));
else
{
if (data <= node.data)
node.left = insert(node.left, data);
else
node.right = insert(node.right, data);
return node;
}
}
static int minValue(Node node)
{
if (node.left == null )
return node.data;
return minValue(node.left);
}
public static void Main(String []args)
{
Node root = null ;
root = insert(root, 4);
insert(root, 2);
insert(root, 1);
insert(root, 3);
insert(root, 6);
insert(root, 5);
Console.WriteLine(minValue(root));
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function newNode(data)
{
var node = new Node();
node.data = data;
node.left = null ;
node.right = null ;
return (node);
}
function insert(node, data)
{
if (node == null )
return (newNode(data));
else
{
if (data <= node.data)
node.left = insert(node.left, data);
else
node.right = insert(node.right, data);
return node;
}
}
function minValue(node)
{
if (node.left == null )
return node.data;
return minValue(node.left);
}
var root = null ;
root = insert(root, 4);
insert(root, 2);
insert(root, 1);
insert(root, 3);
insert(root, 6);
insert(root, 5);
document.write(minValue(root));
</script>
|
Time Complexity: O(n), worst case happens for left skewed trees.
Auxiliary Space : O(n), maximum number of stack frames that could be present in memory is ‘n’
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...