Add all tree operations .

Author: gourabofficial

Tree/FirstExample.java

@@ -11,7 +11,24 @@ public static void main(String[] args) {
 
         // tree.inorder();
         // tree.preorder();
-        tree.postorder();
+        // tree.postorder();
+
+        // int count = tree.countNode(BinaryTree.root);
+        // System.out.println(count);
+
+        int sumOfNodes = tree.sumOfNodes(BinaryTree.root);
+        System.out.print("Sum of the nodes: " + sumOfNodes);
+
+        System.out.println();
+
+        int heightOfTheTree = tree.heightOfTheTree(BinaryTree.root);
+        System.out.println("Height of the Tree is : " + heightOfTheTree);
+
+        System.out.println();
+
+        int diameter = tree.CalculateDiameter(BinaryTree.root);
+        System.out.println("Diameter of the tree is : " + diameter);
+
         System.out.println();
 
     }
@@ -27,8 +44,9 @@ public Node(int data) {
         }
     }
 
-    public static class BinaryTree { 
+    public static class BinaryTree {
         static Node root;
+        static int AnsOfDiamiter = 0;
 
         public static void insertData(int data) {
             root = insertRec(root, data);
@@ -61,32 +79,90 @@ public static void inorderRec(Node root) {
 
         }
 
-        //pre order
-        public static void preorder(){
+        // pre order
+        public static void preorder() {
             preorderRec(root);
         }
-        public static void preorderRec(Node root){
-            if(root == null){
+
+        public static void preorderRec(Node root) {
+            if (root == null) {
                 return;
             }
             System.out.print(root.data + " ");
             preorderRec(root.left);
             preorderRec(root.right);
         }
 
-        //post order
-        public static void postorder(){
+        // post order
+        public static void postorder() {
             postorderRec(root);
         }
 
-        public static void postorderRec(Node root){
-            if(root == null){
+        public static void postorderRec(Node root) {
+            if (root == null) {
                 return;
             }
             postorderRec(root.left);
             postorderRec(root.right);
             System.out.println(root.data + " ");
 
         }
+
+        // count the nodes
+        public static int countNode(Node root) {
+            if (root == null) {
+                return 0;
+            }
+
+            int left = countNode(root.left);
+            int right = countNode(root.right);
+
+            return 1 + left + right;
+        }
+
+        // sun of nodes
+
+        public static int sumOfNodes(Node root) {
+            if (root == null) {
+                return 0;
+            }
+            int left = sumOfNodes(root.left);
+            int right = sumOfNodes(root.right);
+
+            return left + right + root.data;
+        }
+
+        // height of the tree
+
+        public static int heightOfTheTree(Node root) {
+            if (root == null) {
+                return 0;
+            }
+            int left = heightOfTheTree(root.left);
+            int right = heightOfTheTree(root.right);
+
+            return Math.max(left, right) + 1;
+        }
+
+        // diameter of a binary tree
+        public static int CalculateDiameter(Node root){
+            diamiter(root);
+            return AnsOfDiamiter;
+        }
+        public static int diamiter(Node root){
+
+        if(root == null){
+        return 0;
+        }
+
+        int diam1 = diamiter(root.left);
+        int diam2 = diamiter(root.right);
+
+        int finaldiam = diam1 + diam2 + 1;
+        AnsOfDiamiter = Math.max(AnsOfDiamiter, finaldiam);
+        return 1 + Math.max(diam1, diam2);
+
+        }
+
     }
 }

Tree/LevelOrderTravarsal.java

@@ -0,0 +1,78 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class LevelOrderTravarsal {
+
+    public static void main(String[] args) {
+        BinaryTree tree = new BinaryTree();
+        tree.insertData(8);
+        tree.insertData(7);
+        tree.insertData(12);
+        tree.insertData(15);
+        tree.insertData(2);
+        tree.insertData(5);
+
+        // tree.levelorder(BinaryTree.root);
+        tree.levelordertravarsal();
+    }
+
+    // Node class
+    static class Node {
+        int data;
+        Node left;
+        Node right;
+
+        public Node(int data) {
+            this.data = data;
+        }
+    }
+
+    // BinaryTree class
+    public static class BinaryTree {
+        static Node root;
+
+        public static void insertData(int data) {
+            root = insertRec(root, data);
+        }
+
+        private static Node insertRec(Node root, int data) {
+            if (root == null) {
+                return new Node(data);
+            }
+            if (data < root.data) {
+                root.left = insertRec(root.left, data);
+            } else if (data > root.data) {
+                root.right = insertRec(root.right, data);
+            }
+            return root;
+        }
+
+        public void levelordertravarsal() {
+            levelorder(root);
+        }
+
+        public static void levelorder(Node root) {
+            if (root == null) return;
+
+            Queue<Node> q = new LinkedList<>();
+            q.add(root);
+            q.add(null); 
+
+            while (!q.isEmpty()) {
+                Node currNode = q.remove();
+
+                if (currNode == null) {
+                    System.out.println(); 
+                    if (q.isEmpty()) return;
+                    q.add(null);
+                } else {
+                   
+                    System.out.print(currNode.data + " ");
+
+                    if (currNode.left != null) q.add(currNode.left);
+                    if (currNode.right != null) q.add(currNode.right);
+                }
+            }
+        }
+    }
+}