From 6f4f7093151debf249d67e61145f8eb0acc92e05 Mon Sep 17 00:00:00 2001
From: bakhodirsbox <bahodir9293@gmail.com>
Date: Fri, 5 Jan 2018 19:00:28 -0600
Subject: [PATCH 1/2] AVL tree delete method has been added

---
 src/ds/DeleteNodeInAVLTree.java | 108 ++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 src/ds/DeleteNodeInAVLTree.java

diff --git a/src/ds/DeleteNodeInAVLTree.java b/src/ds/DeleteNodeInAVLTree.java
new file mode 100644
index 0000000..52ca4ce
--- /dev/null
+++ b/src/ds/DeleteNodeInAVLTree.java
@@ -0,0 +1,108 @@
+package ds;
+
+@SuppressWarnings("Duplicates")
+public class DeleteNodeInAVLTree<E extends Comparable<E>> {
+    private AVLNode<E> root;
+
+    private int height(AVLNode<E> node) {
+        return node == null ? -1 : node.height;
+    }
+
+    private int max(int a, int b) {
+        return a > b ? a : b;
+    }
+
+    private int getBalance(AVLNode<E> node) {
+        return node == null ? 0 : height(node.left) - height(node.right);
+    }
+
+    public void delete(E elem) {
+        if (elem == null || root == null) throw new IllegalArgumentException();
+        root = deleteHelper(root, elem);
+    }
+
+    private AVLNode<E> deleteHelper(AVLNode<E> node, E elem) {
+        // usual delete node from tree
+        if (node.elem.compareTo(elem) > 0) node.left = deleteHelper(node.left, elem);
+        if (node.elem.compareTo(elem) < 0) node.right = deleteHelper(node.right, elem);
+        else {
+            if (node.left == null && node.right == null) {        // case 1: the node has no child
+                node = null;
+            } else if (node.left == null || node.right == null) { // case 2: the node has a child
+                if (node.left != null) node = node.left;
+                else node = node.right;
+            } else {                                              // case 3: the node has two child
+                AVLNode<E> p = node.left;
+                if (p.right != null) {
+                    while (p.right.right != null) p = p.right;
+                    node.elem = p.right.elem;
+                    p.right = null;
+                } else {
+                    p.right = node.right;
+                    node = p;
+                }
+                node.height = max(height(node.left), height(node.right)) + 1;
+                int balance = getBalance(node);
+
+                // if the node is not balanced
+                // left-left case
+                if (balance > -1 && getBalance(node.left) >= 0) {
+                    return rightRotate(node);
+                }
+                // left-right case
+                if (balance > -1 && getBalance(node.left) < 0) {
+                    node.left = leftRotate(node);
+                    return rightRotate(node);
+                }
+                // right-right case
+                if (balance < -1 && getBalance(node.right) <= 0) {
+                    return leftRotate(node);
+                }
+                // right-left case
+                if (balance < -1 && getBalance(node.right) > -1) {
+                    node.right = rightRotate(node);
+                    return leftRotate(node);
+                }
+            }
+        }
+        return node;
+    }
+
+    private AVLNode<E> leftRotate(AVLNode<E> x) {
+        AVLNode<E> y = x.right;
+        AVLNode<E> z = y.left;
+
+        // rotation
+        y.left = x;
+        x.right = z;
+
+        // update heights
+        x.height = max(height(x.left), height(x.right)) + 1;
+        y.height = max(height(y.left), height(y.right)) + 1;
+        return x;
+    }
+
+    private AVLNode<E> rightRotate(AVLNode<E> y) {
+        AVLNode<E> x = y.left;
+        AVLNode<E> z = x.right;
+
+        //rotation
+        x.right = y;
+        y.left = z;
+
+        // update heights
+        x.height = max(height(x.left), height(x.right)) + 1;
+        y.height = max(height(y.left), height(y.right)) + 1;
+        return x;
+    }
+
+    private class AVLNode<E> {
+        private int height;
+        private E elem;
+        private AVLNode<E> left, right;
+
+        public AVLNode(E elem) {
+            this.elem = elem;
+        }
+    }
+}

From cb340db3fde44bc5e7a07eb565ec586ea73b9211 Mon Sep 17 00:00:00 2001
From: bakhodirsbox <bahodir9293@gmail.com>
Date: Sun, 7 Jan 2018 09:41:17 -0600
Subject: [PATCH 2/2] AVL tree delete method has been added

---
 src/ds/DeleteNodeInAVLTree.java | 107 ++++++++++++++++----------------
 1 file changed, 54 insertions(+), 53 deletions(-)

diff --git a/src/ds/DeleteNodeInAVLTree.java b/src/ds/DeleteNodeInAVLTree.java
index 52ca4ce..c6aaa2d 100644
--- a/src/ds/DeleteNodeInAVLTree.java
+++ b/src/ds/DeleteNodeInAVLTree.java
@@ -1,6 +1,5 @@
 package ds;
 
-@SuppressWarnings("Duplicates")
 public class DeleteNodeInAVLTree<E extends Comparable<E>> {
     private AVLNode<E> root;
 
@@ -16,58 +15,6 @@ private int getBalance(AVLNode<E> node) {
         return node == null ? 0 : height(node.left) - height(node.right);
     }
 
-    public void delete(E elem) {
-        if (elem == null || root == null) throw new IllegalArgumentException();
-        root = deleteHelper(root, elem);
-    }
-
-    private AVLNode<E> deleteHelper(AVLNode<E> node, E elem) {
-        // usual delete node from tree
-        if (node.elem.compareTo(elem) > 0) node.left = deleteHelper(node.left, elem);
-        if (node.elem.compareTo(elem) < 0) node.right = deleteHelper(node.right, elem);
-        else {
-            if (node.left == null && node.right == null) {        // case 1: the node has no child
-                node = null;
-            } else if (node.left == null || node.right == null) { // case 2: the node has a child
-                if (node.left != null) node = node.left;
-                else node = node.right;
-            } else {                                              // case 3: the node has two child
-                AVLNode<E> p = node.left;
-                if (p.right != null) {
-                    while (p.right.right != null) p = p.right;
-                    node.elem = p.right.elem;
-                    p.right = null;
-                } else {
-                    p.right = node.right;
-                    node = p;
-                }
-                node.height = max(height(node.left), height(node.right)) + 1;
-                int balance = getBalance(node);
-
-                // if the node is not balanced
-                // left-left case
-                if (balance > -1 && getBalance(node.left) >= 0) {
-                    return rightRotate(node);
-                }
-                // left-right case
-                if (balance > -1 && getBalance(node.left) < 0) {
-                    node.left = leftRotate(node);
-                    return rightRotate(node);
-                }
-                // right-right case
-                if (balance < -1 && getBalance(node.right) <= 0) {
-                    return leftRotate(node);
-                }
-                // right-left case
-                if (balance < -1 && getBalance(node.right) > -1) {
-                    node.right = rightRotate(node);
-                    return leftRotate(node);
-                }
-            }
-        }
-        return node;
-    }
-
     private AVLNode<E> leftRotate(AVLNode<E> x) {
         AVLNode<E> y = x.right;
         AVLNode<E> z = y.left;
@@ -96,6 +43,60 @@ private AVLNode<E> rightRotate(AVLNode<E> y) {
         return x;
     }
 
+    public void delete(E elem) {
+        if (elem == null) throw new IllegalArgumentException();
+        root = deleteHelper(root, elem);
+    }
+
+    private AVLNode<E> deleteHelper(AVLNode<E> node, E elem) {
+        if (node.elem.compareTo(elem) > 0) node.left = deleteHelper(node.left, elem);
+        else if (node.elem.compareTo(elem) < 0) node.right = deleteHelper(node.right, elem);
+        else {                                             // found, now let's remove it
+            if (node.left == null && node.right == null) {
+                node = null;                               // case 1: if the node has no child
+            } else if (node.left == null || node.right == null) {
+                if (node.left != null) node = node.left;   // case 2: if the node has only one child
+                else node = node.right;
+            } else {                                       // case 3: if the node has two child
+                AVLNode<E> p = findMin(node.left);
+                node.elem = p.elem;
+                node.left = deleteHelper(node.left, p.elem);
+            }
+        }
+
+        if (node == null) return null;
+        node.height = max(height(node.left), height(node.right)) + 1;
+        int balance = getBalance(node);
+
+        // Left Left Case
+        if (balance > 1 && getBalance(root.left) >= 0)
+            return rightRotate(root);
+
+        // Left Right Case
+        if (balance > 1 && getBalance(root.left) < 0) {
+            root.left = leftRotate(root.left);
+            return rightRotate(root);
+        }
+
+        // Right Right Case
+        if (balance < -1 && getBalance(root.right) <= 0)
+            return leftRotate(root);
+
+        // Right Left Case
+        if (balance < -1 && getBalance(root.right) > 0) {
+            root.right = rightRotate(root.right);
+            return leftRotate(root);
+        }
+        return node;
+    }
+
+    private AVLNode<E> findMin(AVLNode<E> node) {
+        while (node.right != null) {
+            node = node.right;
+        }
+        return node;
+    }
+
     private class AVLNode<E> {
         private int height;
         private E elem;