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