Java Program to Find the Minimum value of Binary Search Tree

This is a Java Program to find minimum value of a Binary Search Tree. A binary search tree (BST), sometimes also called an ordered or sorted binary tree, is a node-based binary tree data structure which has the following properties:
i) The left subtree of a node contains only nodes with keys less than the node’s key.
ii) The right subtree of a node contains only nodes with keys greater than the node’s key.
iii) The left and right subtree must each also be a binary search tree.
iv) There must be no duplicate nodes.

Here is the source code of the Java program to minimum value of a Binary Search Tree. The Java program is successfully compiled and run on a Windows system. The program output is also shown below.

/*
 *  Java Program to Find the Minimum value of Binary Search Tree
 */
 
 import java.util.Scanner;
 
 /* Class BSTNode */
 class BSTNode    
 {
     BSTNode left, right;
     int data;
 
     /* Constructor */
     public BSTNode()
     {
         left = null;
         right = null;
         data = 0;
     }
     /* Constructor */
     public BSTNode(int n)
     {
         left = null;
         right = null;
         data = n;
     }         
 }
 
 /* Class BST */
 class BST
 {
     private BSTNode root;
 
     /* Constructor */
     public BST()
     {
         root = null;
     }
     /* Functions to insert data */
     public void insert(int data)
     {
         root = insert(root, data);
     }
     /* Function to insert data recursively */
     private BSTNode insert(BSTNode node, int data)
     {
         if (node == null)
             node = new BSTNode(data);
         else
         {
             if (data <= node.data)
                 node.left = insert(node.left, data);
             else
                 node.right = insert(node.right, data);
         }
         return node;
     }
     /* Function to return least value */
     public int minValue()
     {
         return minValue(root);          
     }
     /* Function to return least value recursively */
     private int minValue(BSTNode r)
     {
         if (r.left == null)
             return r.data;
         return minValue(r.left);        
     }
 
     public void inorder()
     {
         inorder(root);
     }
     private void inorder(BSTNode r)
     {
         if (r != null)
         {
             inorder(r.left);
             System.out.print(r.data +" ");
             inorder(r.right);
         }
     }
     /* Function for preorder traversal */
     public void preorder()
     {
         preorder(root);
     }
     private void preorder(BSTNode r)
     {
         if (r != null)
         {
             System.out.print(r.data +" ");
             preorder(r.left);             
             preorder(r.right);
         }
     }
     /* Function for postorder traversal */
     public void postorder()
     {
         postorder(root);
     }
     private void postorder(BSTNode r)
     {
         if (r != null)
         {
             postorder(r.left);             
             postorder(r.right);
             System.out.print(r.data +" ");
         }
     }     
 }
 
 /* Class MinValueBST */
 public class MinValueBST
 {
     public static void main(String[] args)
     {                 
         Scanner scan = new Scanner(System.in);
         /* Creating object of BST */
         BST bst = new BST(); 
         System.out.println("Minimum Value of Binary Search Tree Test\n");          
         char ch;
         /*  Accept input  */
         do    
         {
             System.out.println("Enter integer element to insert");
             bst.insert( scan.nextInt() );                     
 
             /*  Display tree  */ 
             System.out.print("\nPost order : ");
             bst.postorder();
             System.out.print("\nPre order : "); 
             bst.preorder();
             System.out.print("\nIn order : ");
             bst.inorder(); 
 
             System.out.println("\nDo you want to continue (Type y or n) \n");
             ch = scan.next().charAt(0);                        
         } while (ch == 'Y'|| ch == 'y'); 
 
         System.out.println("\nMnimum value of the Binary Search Tree is : "+ bst.minValue());              
     }
 }
Minimum Value of Binary Search Tree Test
 
Enter integer element to insert
56
 
Post order : 56
Pre order : 56
In order : 56
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
23
 
Post order : 23 56
Pre order : 56 23
In order : 23 56
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
80
 
Post order : 23 80 56
Pre order : 56 23 80
In order : 23 56 80
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
12
 
Post order : 12 23 80 56
Pre order : 56 23 12 80
In order : 12 23 56 80
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
234
 
Post order : 12 23 234 80 56
Pre order : 56 23 12 80 234
In order : 12 23 56 80 234
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
546
 
Post order : 12 23 546 234 80 56
Pre order : 56 23 12 80 234 546
In order : 12 23 56 80 234 546
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
6
 
Post order : 6 12 23 546 234 80 56
Pre order : 56 23 12 6 80 234 546
In order : 6 12 23 56 80 234 546
Do you want to continue (Type y or n)
 
y
Enter integer element to insert
32
 
Post order : 6 12 32 23 546 234 80 56
Pre order : 56 23 12 6 32 80 234 546
In order : 6 12 23 32 56 80 234 546
Do you want to continue (Type y or n)
 
n
 
Mnimum value of the Binary Search Tree is : 6

Related posts:

Java Program to Implement ArrayList API
Java Web Services – Jersey JAX-RS – REST và sử dụng REST API testing tools với Postman
A Quick Guide to Spring Cloud Consul
Java Program to Use Dynamic Programming to Solve Approximate String Matching
Java Program to Find Maximum Element in an Array using Binary Search
Java Program to Implement RoleList API
Lập trình mạng với java
Jackson vs Gson
How to Find an Element in a List with Java
Introduction to Thread Pools in Java
Spring Boot - Cloud Configuration Server
Java Program to Find Number of Spanning Trees in a Complete Bipartite Graph
Java Program to Implement ArrayBlockingQueue API
Hướng dẫn Java Design Pattern – Dependency Injection
Iterating over Enum Values in Java
Java Program to Create the Prufer Code for a Tree
Java Program to Implement Knapsack Algorithm
Java Program to do a Depth First Search/Traversal on a graph non-recursively
Java Program to Check Cycle in a Graph using Graph traversal
Jackson – Marshall String to JsonNode
Java Program to Implement Ternary Search Algorithm
Intersection of Two Lists in Java
Java Program to Implement LinkedBlockingDeque API
Spring Boot - Code Structure
JUnit 5 for Kotlin Developers
Converting Between a List and a Set in Java
Reading an HTTP Response Body as a String in Java
Java Program to Represent Linear Equations in Matrix Form
Java Program to Implement CopyOnWriteArrayList API
Java Program to Encode a Message Using Playfair Cipher
Java Program to Test Using DFS Whether a Directed Graph is Weakly Connected or Not
Sending Emails with Java