Posted on by Kalkicode
Code Binary Search Tree

# Find minimum node in binary search tree

Here given code implementation process.

``````//C Program
//Find minimum node in binary search tree
#include <stdio.h>

#include <stdlib.h>
//structure of Binary Search Tree node
struct Node
{
int data;
struct Node *left, *right;
};
//Adding a new node in binary search tree
void add_node(struct Node **root, int data)
{
//Create a dynamic node of binary search tree
struct Node *new_node = (struct Node *) malloc(sizeof(struct Node));
if (new_node != NULL)
{
//Set data and pointer values
new_node->data = data;
new_node->left = NULL; //Initially node left-pointer is NULL
new_node->right = NULL; //Initially node right-pointer is NULL
if ( *root == NULL)
{
//When adds a first node in binary tree
*root = new_node;
}
else
{
struct Node *find = *root;
//iterate binary tree and add new node to proper position
while (find != NULL)
{
if (find->data > data)
{
if (find->left == NULL)
{
find->left = new_node;
break;
}
else
{ //visit left sub-tree
find = find->left;
}
}
else
{
if (find->right == NULL)
{
find->right = new_node;
break;
}
else
{
//visit right sub-tree
find = find->right;
}
}
}
}
}
else
{
printf("Memory Overflow\n");
exit(0); //Terminate program execution
}
}
//Find and print minimum node of binary search tree
void min_node(struct Node *root)
{
if (root == NULL)
{
printf("\n Empty Tree");
}
else
{
printf(" Minimum node is : ");
struct Node *temp = root;
//Find leftmost node from to root
while (temp->left != NULL)
{
//Visit left node
temp = temp->left;
}
//Display node value
printf("%d\n", temp->data);
}
}
int main()
{
struct Node *root = NULL;
//Add nodes in binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
min_node(root);
return 0;
}``````

#### Output

`` Minimum node is : -7``
``````//Java program
//Find minimum node in binary search tree
//Binary Tree Node
class Node
{
public int data;
public Node left;
public Node right;
public Node(int data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
class BinarySearchTree
{
public Node root;
//Class constructors
public BinarySearchTree()
{
root = null;
}
//insert  element
{
//Create a new binary tree node
Node new_node = new Node(data);
if (new_node != null)
{
if (this.root == null)
{
//When adds a first node in binary tree
this.root = new_node;
}
else
{
Node find = this.root;
//add new node to proper position
while (find != null)
{
if (find.data >= data)
{
if (find.left == null)
{
find.left = new_node;
break;
}
else
{
//visit left sub-tree
find = find.left;
}
}
else
{
if (find.right == null)
{
find.right = new_node;
break;
}
else
{
//visit right sub-tree
find = find.right;
}
}
}
}
}
else
{
System.out.println("Memory Overflow");
}
}
//Find and print minimum node of binary search tree
public void min_node()
{
if (root == null)
{
System.out.print("\n Empty Tree");
}
else
{
System.out.print(" Minimum node is : ");
Node temp = root;
//Find leftmost node from to root
while (temp.left != null)
{
//Visit left node
temp = temp.left;
}
System.out.print(" " + temp.data + "\n");
}
}
public static void main(String[] args)
{
BinarySearchTree obj = new BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
}
}``````

#### Output

`` Minimum node is :  -7``
``````//Include header file
#include <iostream>
using namespace std;

//C++ program
//Find minimum node in binary search tree
//Binary Tree Node
class Node
{
public: int data;
Node * left;
Node * right;
Node(int data)
{
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
class BinarySearchTree
{
public: Node * root;
//Class constructors
BinarySearchTree()
{
this->root = NULL;
}
//insert  element
{
//Create a new binary tree node
Node * new_node = new Node(data);
if (new_node != NULL)
{
if (this->root == NULL)
{
//When adds a first node in binary tree
this->root = new_node;
}
else
{
Node * find = this->root;
//add new node to proper position
while (find != NULL)
{
if (find->data >= data)
{
if (find->left == NULL)
{
find->left = new_node;
break;
}
else
{
//visit left sub-tree
find = find->left;
}
}
else
{
if (find->right == NULL)
{
find->right = new_node;
break;
}
else
{
//visit right sub-tree
find = find->right;
}
}
}
}
}
else
{
cout << "Memory Overflow";
}
}
//Find and print minimum node of binary search tree
void min_node()
{
if (this->root == NULL)
{
cout << "\n Empty Tree";
}
else
{
cout << " Minimum node is : ";
Node * temp = this->root;
//Find leftmost node from to root
while (temp->left != NULL)
{
//Visit left node
temp = temp->left;
}
cout << " " << temp->data << "\n";
}
}
};
int main()
{
BinarySearchTree obj = BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
return 0;
}``````

#### Output

`` Minimum node is :  -7``
``````//Include namespace system
using System;

//C# program
//Find minimum node in binary search tree
//Binary Tree Node
public class Node
{
public int data;
public Node left;
public Node right;
public Node(int data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
class BinarySearchTree
{
public Node root;
//Class constructors
public BinarySearchTree()
{
root = null;
}
//insert  element
{
//Create a new binary tree node
Node new_node = new Node(data);
if (new_node != null)
{
if (this.root == null)
{
//When adds a first node in binary tree
this.root = new_node;
}
else
{
Node find = this.root;
//add new node to proper position
while (find != null)
{
if (find.data >= data)
{
if (find.left == null)
{
find.left = new_node;
break;
}
else
{
//visit left sub-tree
find = find.left;
}
}
else
{
if (find.right == null)
{
find.right = new_node;
break;
}
else
{
//visit right sub-tree
find = find.right;
}
}
}
}
}
else
{
Console.WriteLine("Memory Overflow");
}
}
//Find and print minimum node of binary search tree
public void min_node()
{
if (root == null)
{
Console.Write("\n Empty Tree");
}
else
{
Console.Write(" Minimum node is : ");
Node temp = root;
//Find leftmost node from to root
while (temp.left != null)
{
//Visit left node
temp = temp.left;
}
Console.Write(" " + temp.data + "\n");
}
}
public static void Main(String[] args)
{
BinarySearchTree obj = new BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
}
}``````

#### Output

`` Minimum node is :  -7``
``````<?php
//Php program
//Find minimum node in binary search tree
//Binary Tree Node
class Node
{
public \$data;
public \$left;
public \$right;

function __construct(\$data)
{
\$this->data = \$data;
\$this->left = null;
\$this->right = null;
}
}
class BinarySearchTree
{
public \$root;
//Class constructors
function __construct()
{
\$this->root = null;
}
//insert  element
{
//Create a new binary tree node
\$new_node = new Node(\$data);
if (\$new_node != null)
{
if (\$this->root == null)
{
//When adds a first node in binary tree
\$this->root = \$new_node;
}
else
{
\$find = \$this->root;
//add new node to proper position
while (\$find != null)
{
if (\$find->data >= \$data)
{
if (\$find->left == null)
{
\$find->left = \$new_node;
break;
}
else
{
//visit left sub-tree
\$find = \$find->left;
}
}
else
{
if (\$find->right == null)
{
\$find->right = \$new_node;
break;
}
else
{
//visit right sub-tree
\$find = \$find->right;
}
}
}
}
}
else
{
echo "Memory Overflow";
}
}
//Find and print minimum node of binary search tree
public	function min_node()
{
if (\$this->root == null)
{
echo "\n Empty Tree";
}
else
{
echo " Minimum node is : ";
\$temp = \$this->root;
//Find leftmost node from to root
while (\$temp->left != null)
{
//Visit left node
\$temp = \$temp->left;
}
echo " ". \$temp->data ."\n";
}
}
}

function main()
{
\$obj = new BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
\$obj->min_node();
}
main();``````

#### Output

`` Minimum node is :  -7``
``````//Node Js program
//Find minimum node in binary search tree
//Binary Tree Node
class Node
{
constructor(data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
class BinarySearchTree
{
//Class constructors
constructor()
{
this.root = null;
}
//insert  element
{
//Create a new binary tree node
var new_node = new Node(data);
if (new_node != null)
{
if (this.root == null)
{
//When adds a first node in binary tree
this.root = new_node;
}
else
{
var find = this.root;
//add new node to proper position
while (find != null)
{
if (find.data >= data)
{
if (find.left == null)
{
find.left = new_node;
break;
}
else
{
//visit left sub-tree
find = find.left;
}
}
else
{
if (find.right == null)
{
find.right = new_node;
break;
}
else
{
//visit right sub-tree
find = find.right;
}
}
}
}
}
else
{
process.stdout.write("Memory Overflow");
}
}
//Find and print minimum node of binary search tree
min_node()
{
if (this.root == null)
{
process.stdout.write("\n Empty Tree");
}
else
{
process.stdout.write(" Minimum node is : ");
var temp = this.root;
//Find leftmost node from to root
while (temp.left != null)
{
//Visit left node
temp = temp.left;
}
process.stdout.write(" " + temp.data + "\n");
}
}
}

function main()
{
var obj = new BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
}
main();``````

#### Output

`` Minimum node is :  -7``
``````# Python 3 program
# Find minimum node in binary search tree
# Binary Tree Node
class Node :

def __init__(self, data) :
self.data = data
self.left = None
self.right = None

class BinarySearchTree :

# Class constructors
def __init__(self) :
self.root = None

# insert  element
# Create a new binary tree node
new_node = Node(data)
if (new_node != None) :
if (self.root == None) :
# When adds a first node in binary tree
self.root = new_node
else :
find = self.root
# add new node to proper position
while (find != None) :
if (find.data >= data) :
if (find.left == None) :
find.left = new_node
break
else :
# visit left sub-tree
find = find.left

else :
if (find.right == None) :
find.right = new_node
break
else :
# visit right sub-tree
find = find.right

else :
print("Memory Overflow", end = "")

# Find and print minimum node of binary search tree
def min_node(self) :
if (self.root == None) :
print("\n Empty Tree", end = "")
else :
print(" Minimum node is : ", end = "")
temp = self.root
# Find leftmost node from to root
while (temp.left != None) :
# Visit left node
temp = temp.left

print(" ", temp.data ,"\n", end = "")

def main() :
obj = BinarySearchTree()
# Create binary search tree
#
# 		       5
# 		     /    \
# 		    3      9
# 		   / \     / \
# 		 -7   4   8   11
# 		   \     /      \
# 		    2   7        12
#

obj.min_node()

if __name__ == "__main__": main()``````

#### Output

`` Minimum node is :   -7``
``````# Ruby program
# Find minimum node in binary search tree
# Binary Tree Node
class Node

# Define the accessor and reader of class Node
attr_accessor :data, :left, :right

def initialize(data)

self.data = data
self.left = nil
self.right = nil
end
end
class BinarySearchTree

# Define the accessor and reader of class BinarySearchTree
attr_accessor :root

# Class constructors
def initialize()

@root = nil
end
# insert  element

# Create a new binary tree node
new_node = Node.new(data)
if (new_node != nil)

if (self.root == nil)

# When adds a first node in binary tree
self.root = new_node
else

find = self.root
# add new node to proper position
while (find != nil)

if (find.data >= data)

if (find.left == nil)

find.left = new_node
break
else

# visit left sub-tree
find = find.left
end
else

if (find.right == nil)

find.right = new_node
break
else

# visit right sub-tree
find = find.right
end
end
end
end
else

print("Memory Overflow")
end
end
# Find and print minimum node of binary search tree
def min_node()

if (@root == nil)

print("\n Empty Tree")
else

print(" Minimum node is : ")
temp = @root
# Find leftmost node from to root
while (temp.left != nil)

# Visit left node
temp = temp.left
end
print(" ", temp.data ,"\n")
end
end
end
def main()

obj = BinarySearchTree.new()
# Create binary search tree
#
# 		       5
# 		     /    \
# 		    3      9
# 		   / \     / \
# 		 -7   4   8   11
# 		   \     /      \
# 		    2   7        12
#

obj.min_node()
end
main()``````

#### Output

`````` Minimum node is :  -7
``````
``````//Scala program
//Find minimum node in binary search tree
//Binary Tree Node
class Node(var data: Int,
var left: Node,
var right: Node)
{
def this(data: Int)
{
this(data, null, null);
}
}
class BinarySearchTree(var root: Node)
{
//Class constructors
def this()
{
this(null);
}
//insert  element
def add_node(data: Int): Unit = {
//Create a new binary tree node
var new_node: Node = new Node(data);
if (new_node != null)
{
if (this.root == null)
{
//When adds a first node in binary tree
this.root = new_node;
}
else
{
var find: Node = this.root;
//add new node to proper position
while (find != null)
{
if (find.data >= data)
{
if (find.left == null)
{
find.left = new_node;
return;
}
else
{
//visit left sub-tree
find = find.left;
}
}
else
{
if (find.right == null)
{
find.right = new_node;
return;
}
else
{
//visit right sub-tree
find = find.right;
}
}
}
}
}
else
{
print("Memory Overflow");
}
}
//Find and print minimum node of binary search tree
def min_node(): Unit = {
if (root == null)
{
print("\n Empty Tree");
}
else
{
print(" Minimum node is : ");
var temp: Node = root;
//Find leftmost node from to root
while (temp.left != null)
{
//Visit left node
temp = temp.left;
}
print(" " + temp.data + "\n");
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var obj: BinarySearchTree = new BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
}
}``````

#### Output

`` Minimum node is :  -7``
``````//Swift program
//Find minimum node in binary search tree
//Binary Tree Node
class Node
{
var data: Int;
var left: Node? ;
var right: Node? ;
init(_ data: Int)
{
self.data = data;
self.left = nil;
self.right = nil;
}
}
class BinarySearchTree
{
var root: Node? ;
//Class constructors
init()
{
self.root = nil;
}
//insert  element
{
//Create a new binary tree node
let new_node: Node? = Node(data);
if (new_node != nil)
{
if (self.root == nil)
{
//When adds a first node in binary tree
self.root = new_node;
}
else
{
var find: Node? = self.root;
//add new node to proper position
while (find != nil)
{
if (find!.data >= data)
{
if (find!.left == nil)
{
find!.left = new_node;
break;
}
else
{
//visit left sub-tree
find = find!.left;
}
}
else
{
if (find!.right == nil)
{
find!.right = new_node;
break;
}
else
{
//visit right sub-tree
find = find!.right;
}
}
}
}
}
else
{
print("Memory Overflow", terminator: "");
}
}
//Find and print minimum node of binary search tree
func min_node()
{
if (self.root == nil)
{
print("\n Empty Tree", terminator: "");
}
else
{
print(" Minimum node is : ", terminator: "");
var temp: Node? = self.root;
//Find leftmost node from to root
while (temp!.left != nil)
{
//Visit left node
temp = temp!.left;
}
print(" ", temp!.data ,"\n", terminator: "");
}
}
}
func main()
{
let obj: BinarySearchTree = BinarySearchTree();
//Create binary search tree
/*
5
/    \
3      9
/ \     / \
-7   4   8   11
\     /      \
2   7        12
*/
obj.min_node();
}
main();``````

#### Output

`` Minimum node is :   -7``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post