add lesson6 homework

lesson6/src/Main.java

@@ -0,0 +1,21 @@
+import java.util.ArrayList;
+
+public class Main {
+    public static void main(String[] args) {
+        ArrayList<Tree> trees = new ArrayList<>();
+        int balancedTrees = 0;
+        int numberOfTrees = 1_000_000;
+
+        for (int i = 0; i < numberOfTrees; i++) {
+            trees.add(Tree.generateRandomTree());
+        }
+
+        for (int i = 0; i < trees.size(); i++) {
+            if (trees.get(i).isBalanced())
+                balancedTrees++;
+        }
+
+        System.out.printf("%.2f%% of %d trees are balanced", balancedTrees * 100.0f / numberOfTrees, numberOfTrees);
+
+    }
+}

lesson6/src/Tree.java

@@ -1,11 +1,15 @@
 public class Tree {
     private class TreeNode {
         private Cat c;
+        private int n;
         public TreeNode left;
         public TreeNode right;
         public TreeNode(Cat c) {
             this.c = c;
         }
+        public TreeNode(int n) {
+            this.n = n;
+        }
         @Override
         public String toString() {
             return String.format("(I:%d, N:%s, A:%d)", c.id, c.name, c.age);
@@ -53,6 +57,69 @@ public void insert(Cat c) {
             }
         }
     }
+
+    public boolean isBalanced() {
+        return isBalancedHelper(root);
+    }
+
+    private int getHeight(TreeNode node) {
+        if (node == null)
+            return 0;
+        if (node.left == null && node.right == null)
+            return 1;
+        if (node.right == null)
+            return getHeight(node.left) + 1;
+        if (node.left == null)
+            return getHeight(node.right) + 1;
+
+        return Math.max(getHeight(node.left),  getHeight(node.right)) + 1;
+    }
+
+    private boolean isBalancedHelper(TreeNode current) {
+        if (current == null)
+            return true;
+        if (current.left == null && current.right == null)
+            return true;
+
+        int diff = Math.abs(getHeight(current.left) - getHeight(current.right));
+
+        return isBalancedHelper(current.left) && isBalancedHelper(current.right) && diff <= 1;
+
+    }
+
+    public static Tree generateRandomTree() {
+        Tree tree = new Tree();
+        for (int i = 0; i < 10; i++) {
+            tree.insert((int) (Math.round(Math.random()*200.00 - 100.00)));
+        }
+        return tree;
+    }
+
+    public void insert(int n) {
+        TreeNode node = new TreeNode(n);
+        if (root == null) {
+            root = node;
+        } else {
+            TreeNode current = root;
+            TreeNode previous;
+            while (true) {
+                previous = current;
+                if (n < current.n) {
+                    current = current.left;
+                    if (current == null) {
+                        previous.left = node;
+                        return;
+                    }
+                } else {
+                    current = current.right;
+                    if (current == null) {
+                        previous.right = node;
+                        return;
+                    }
+                }
+            }
+        }
+    }
 
     public void displayTree() {
         inOrderTravers(root);