From 45f614ff0debd00fa8696e21336682dda0f48669 Mon Sep 17 00:00:00 2001
From: sergeynikitin <sergeynikitin2020@icloud.com>
Date: Sat, 17 Jul 2021 18:47:24 +0300
Subject: [PATCH 1/4] Create TreeMap

---
 src/algorithmsAndDataStructures/Main.java     |  22 +-
 .../MyTreeMap.java                            | 221 ++++++++++++++++++
 2 files changed, 241 insertions(+), 2 deletions(-)
 create mode 100644 src/algorithmsAndDataStructures/MyTreeMap.java

diff --git a/src/algorithmsAndDataStructures/Main.java b/src/algorithmsAndDataStructures/Main.java
index ba454e2..d0bf500 100644
--- a/src/algorithmsAndDataStructures/Main.java
+++ b/src/algorithmsAndDataStructures/Main.java
@@ -1,8 +1,26 @@
 package algorithmsAndDataStructures;
 
+import java.util.concurrent.ThreadLocalRandom;
+
 public class Main {
 
     public static void main(String[] args) {
-	// write your code here
+        final int count = 100000;
+        int isBalance = 0;
+
+        for (int i = 0; i < count; i++) {
+            MyTreeMap<Integer, Integer> treeMap = new MyTreeMap<>();
+            while (treeMap.height() < 6) {
+                treeMap.put(ThreadLocalRandom.current().nextInt(-100, 100),
+                        ThreadLocalRandom.current().nextInt(0, 100));
+            }
+            System.out.println(treeMap);
+
+            if (treeMap.isBalance())
+                isBalance++;
+        }
+        System.out.println("Total wood: " + count +
+                ", balanced wood: " + isBalance +
+                ", not balanced wood: " + (count - isBalance));
     }
-}
+}
\ No newline at end of file
diff --git a/src/algorithmsAndDataStructures/MyTreeMap.java b/src/algorithmsAndDataStructures/MyTreeMap.java
new file mode 100644
index 0000000..c201a74
--- /dev/null
+++ b/src/algorithmsAndDataStructures/MyTreeMap.java
@@ -0,0 +1,221 @@
+package algorithmsAndDataStructures;
+
+import java.util.NoSuchElementException;
+
+public class MyTreeMap<K extends Comparable<K>, V> {
+    private Node root;
+
+    private class Node {
+        int height;
+        K key;
+        V value;
+        Node left;
+        Node right;
+        int size;
+
+        public Node(K key, V value, int size, int height) {
+            this.key = key;
+            this.value = value;
+            this.size = size;
+            this.height = height;
+        }
+    }
+
+    public int size() {
+        return size(root);
+    }
+
+    private int size(Node node) {
+        if (node == null) {
+            return 0;
+        }
+        return node.size;
+    }
+
+    public boolean isEmpty() {
+        return root == null;
+    }
+
+    private void checkKeyNotNull(K key) {
+        if (key == null) {
+            throw new IllegalArgumentException("key не должен быть null");
+        }
+    }
+
+    public boolean contains(K key) {
+        return get(key) != null;
+    }
+
+    public V get(K key) {
+        checkKeyNotNull(key);
+        return get(root, key);
+    }
+
+    private V get(Node node, K key) {
+        if (node == null) {
+            return null;
+        }
+        int cmp = key.compareTo(node.key);
+        if (cmp == 0) {
+            return node.value;
+        } else if (cmp < 0) {
+            return get(node.left, key);
+        } else {
+            return get(node.right, key);
+        }
+    }
+
+    public void put(K key, V value) {
+        checkKeyNotNull(key);
+        if (value == null) {
+            return;
+        }
+        root = put(root, key, value);
+    }
+
+    private Node put(Node node, K key, V value) {
+        if (node == null) {
+            return new Node(key, value, 1, 0);
+        }
+        int cmp = key.compareTo(node.key);
+        if (cmp == 0) {
+            node.value = value;
+        } else if (cmp < 0) {
+            node.left = put(node.left, key, value);
+        } else {
+            node.right = put(node.right, key, value);
+        }
+        node.size = 1 + size(node.left) + size(node.right);
+        if (node.left == null && node.right == null) {
+            node.height = 0;
+        } else if (node.left != null && node.right == null) {
+            node.height = 1 + node.left.height;
+        } else if (node.left == null) {
+            node.height = 1 + node.right.height;
+        } else if (node.left.height > node.right.height) {
+            node.height = 1 + node.left.height;
+        } else if (node.left.height < node.right.height) {
+            node.height = 1 + node.right.height;
+        } else {
+            node.height = 1 + node.left.height;
+        }
+
+        return node;
+    }
+
+    private Node max(Node node) {
+        if (node.right == null) {
+            return node;
+        }
+        return max(node.right);
+    }
+
+    public K maxKey() {
+        return max(root).key;
+    }
+
+
+    public K minKey() {
+        return min(root).key;
+    }
+
+    private Node min(Node node) {
+        if (node.left == null) {
+            return node;
+        }
+        return min(node.left);
+    }
+
+    public void deleteMin() {
+        if (isEmpty()) {
+            throw new NoSuchElementException();
+        }
+        root = deleteMin(root);
+    }
+
+    private Node deleteMin(Node node) {
+        if (node.left == null) {
+            return node.right;
+        }
+        node.left = deleteMin(node.left);
+        node.size = 1 + size(node.left) + size(node.right);
+        return node;
+    }
+
+    public void delete(K key) {
+        checkKeyNotNull(key);
+        root = delete(root, key);
+    }
+
+    private Node delete(Node node, K key) {
+        if (node == null) {
+            return null;
+        }
+        int cmp = key.compareTo(node.key);
+        if (cmp < 0) {
+            node.left = delete(node.left, key);
+        } else if (cmp > 0) {
+            node.right = delete(node.right, key);
+        } else {
+            if (node.left == null) {
+                return node.right;
+            }
+            if (node.right == null) {
+                return node.left;
+            }
+            Node temp = node;
+            node = min(node.right);
+            node.right = deleteMin(temp.right);
+            node.left = temp.left;
+        }
+        node.size = 1 + size(node.left) + size(node.right);
+        return node;
+
+    }
+
+    public int height() {
+        return height(root);
+    }
+
+    private int height(Node node) {
+        if (node == null) {
+            return 0;
+        }
+        return node.height;
+    }
+
+    public boolean isBalance() {
+        if (root == null || root.size == 1) {
+            return true;
+        } else {
+            int heightLeft;
+            int heightRight;
+
+            if (root.left == null) {
+                heightLeft = 0;
+            } else {
+                heightLeft = root.left.height;
+            }
+
+            if (root.right == null) {
+                heightRight = 0;
+            } else {
+                heightRight = root.right.height;
+            }
+            return Math.abs(heightLeft - heightRight) <= 1;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return toString(root);
+    }
+
+    private String toString(Node node) {
+        if (node == null) {
+            return "";
+        }
+        return toString(node.left) + "[" + node.key + ", " + node.value + "]" +
+                toString(node.right);
+    }
+}
\ No newline at end of file

From ad469b8cc697fdafd03c0cfc676350ac4aa01994 Mon Sep 17 00:00:00 2001
From: SerjNikitin <76908941+SerjNikitin@users.noreply.github.com>
Date: Sat, 17 Jul 2021 18:51:07 +0300
Subject: [PATCH 2/4] Create README.md

---
 README.md | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..87c8b02
--- /dev/null
+++ b/README.md
@@ -0,0 +1,7 @@
+# AlgorithmsAndDataStructures
+1. Создать и запустить программу для построения двоичного дерева.
+В цикле построить двадцать деревьев с глубиной в 6 уровней.
+Данные, которыми необходимо заполнить узлы деревьев, представляются в виде чисел типа int.
+Число, которое попадает в узел, должно генерироваться случайным образом в диапазоне от -100 до 100.
+
+2. Проанализировать, какой процент созданных деревьев являются несбалансированными.

From f045e83fe7c8ad55fe6e6133ea5d18bfc58db6b3 Mon Sep 17 00:00:00 2001
From: sergeynikitin <sergeynikitin2020@icloud.com>
Date: Wed, 21 Jul 2021 11:03:44 +0300
Subject: [PATCH 3/4] Create TreeMap

---
 .../MyTreeMap.java                            | 31 ++++++++++---------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/algorithmsAndDataStructures/MyTreeMap.java b/src/algorithmsAndDataStructures/MyTreeMap.java
index c201a74..3052b55 100644
--- a/src/algorithmsAndDataStructures/MyTreeMap.java
+++ b/src/algorithmsAndDataStructures/MyTreeMap.java
@@ -86,20 +86,7 @@ private Node put(Node node, K key, V value) {
             node.right = put(node.right, key, value);
         }
         node.size = 1 + size(node.left) + size(node.right);
-        if (node.left == null && node.right == null) {
-            node.height = 0;
-        } else if (node.left != null && node.right == null) {
-            node.height = 1 + node.left.height;
-        } else if (node.left == null) {
-            node.height = 1 + node.right.height;
-        } else if (node.left.height > node.right.height) {
-            node.height = 1 + node.left.height;
-        } else if (node.left.height < node.right.height) {
-            node.height = 1 + node.right.height;
-        } else {
-            node.height = 1 + node.left.height;
-        }
-
+        height(node);
         return node;
     }
 
@@ -139,6 +126,7 @@ private Node deleteMin(Node node) {
         }
         node.left = deleteMin(node.left);
         node.size = 1 + size(node.left) + size(node.right);
+        height(node);
         return node;
     }
 
@@ -169,8 +157,8 @@ private Node delete(Node node, K key) {
             node.left = temp.left;
         }
         node.size = 1 + size(node.left) + size(node.right);
+        height(node);
         return node;
-
     }
 
     public int height() {
@@ -181,6 +169,19 @@ private int height(Node node) {
         if (node == null) {
             return 0;
         }
+        if (node.left == null && node.right == null) {
+            node.height = 0;
+        } else if (node.left != null && node.right == null) {
+            node.height = 1 + node.left.height;
+        } else if (node.left == null) {
+            node.height = 1 + node.right.height;
+        } else if (node.left.height > node.right.height) {
+            node.height = 1 + node.left.height;
+        } else if (node.left.height < node.right.height) {
+            node.height = 1 + node.right.height;
+        } else {
+            node.height = 1 + node.left.height;
+        }
         return node.height;
     }
 

From f2433bdddce3323fe6957e5c868f10d749bb1474 Mon Sep 17 00:00:00 2001
From: sergeynikitin <sergeynikitin2020@icloud.com>
Date: Wed, 21 Jul 2021 17:31:02 +0300
Subject: [PATCH 4/4] Rename branch

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 87c8b02..06283e7 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,5 @@
 # AlgorithmsAndDataStructures
+Create TreeMap
 1. Создать и запустить программу для построения двоичного дерева.
 В цикле построить двадцать деревьев с глубиной в 6 уровней.
 Данные, которыми необходимо заполнить узлы деревьев, представляются в виде чисел типа int.