Java program to determine whether all leaves are at same level

In this program, we must determine whether or not all of the binary tree's leaves are at the same level.

If a node has no child nodes, it is said to be a leaf. Nodes 10, 14, and 12 in the figure below are leaf nodes since they don't have any child nodes. Level 2 has Nodes 10, 14, and 12.

Algorithm

• Define the Node class, which has three properties: data left, data right, and cloud server. Left here indicates the node's left child, and right here represents the node's right child.
• Data is passed to the node's data attribute at formation, and left and right are both set to null.
• Define a different class with the parameters root and level.
• Root initialises the root node of the tree to null and represents it.
• The first leaf node encountered will have its level saved in the level.

The function isSameLevel() determines whether or not every node in a binary tree is at the same level.

• It verifies to see if the root is null, which implies an empty tree.
• Navigate the tree and search about any tree structure with null left and right children if it is not empty.
• The level that is currently being travelled will be maintained by CurrentLevel.
• Save the currentLevel value in the variable level when the first leaf node is reached.
• Recursively traverse each level, looking for more tree structure. All leaves are at the same level if currentLevel for every leaf equals the value contained in level.

LeafLevel.java

public class LeafLevel {  
    //represent a binary tree node.
    public static class Node{  
        int data;  
        Node left;  
        Node right; 
        public Node(int data){  
            //Give the new node data, and then set the left and right children to null  
            this.data = data;  
            this.left = null;  
            this.right = null;  
            }  
        }  
    //represent the binary tree's root 
    public Node root;  
    //It will save the first encountered leaf level.  
    public static int level = 0;    
    public LeafLevel(){  
        root = null;  
    }    
    //If the binary tree's leaves are all at the same level, isSameLevel() will determine whether they are  
    public boolean isSameLevel(Node temp, int currentLevel ) {   
        //Verify that the tree is empty.
        if(root == null){  
          System.out.println("Tree is empty");  
          return true;  
        }  
        else {  
            //determines whether node is null 
            if(temp==null)  
                return true;    
            if(temp.left == null && temp.right == null) {  
                //If the first leaf is found, the level is set to the current level.  
                if(level == 0) {  
                    level = currentLevel ;  
                    return true;  
                }  
                //analyzes the other leaves to see if they are at the same level as the first leaf 
                else  
                   return (level == currentLevel) ;  
             }  
 
            //iteratively looks for leaf nodes in the left and right subtrees. 
            return  (isSameLevel(temp.left, currentLevel + 1) && isSameLevel(temp.right, currentLevel + 1)) ;  
         }  
    }    
    public static void main (String[] args) {   
        LeafLevel bt = new LeafLevel();  
        //Adding nodes to the binary tree 
        bt.root = new Node(2);  
        bt.root.left = new Node(4);  
        bt.root.right = new Node(6);  
        bt.root.left.left = new Node(8);  
        bt.root.right.left = new Node(10);  
        bt.root.right.right = new Node(12);    
        //determines if every leaf in a binary tree is at the same level.
        if(bt.isSameLevel(bt.root, 1))  
            System.out.println("The level of each leaf is the same.");  
        else  
            System.out.println("The level of each leaf is the not same");  
  }  
}  

Output: