Self Balancing Tree

Author: alexprut

Data Structures/Balanced Trees/Self Balancing Tree/Solution.java

@@ -0,0 +1,120 @@
+   /* Class node is defined as :
+    class Node
+       int val;   //Value
+       int ht;      //Height
+       Node left;   //Left child
+       Node right;   //Right child
+
+   */
+
+static Node insert(Node root,int val) {
+    Node newNode = new Node();
+    newNode.val = val;
+    newNode.ht = 0;
+    newNode.left = null;
+    newNode.right = null;
+
+    if (root==null) {
+        root = newNode;
+    } else {
+        root=avlinsert(newNode, root);
+    }
+
+    return root;
+}
+
+// return height of tree rooted at x
+static public int height(Node x) {
+    if (x == null) return -1;
+    else return x.ht;
+}
+
+static public Node rotatewithleft(Node c) {
+    Node p;  // left child of c
+
+    p = c.left;
+    c.left = p.right;
+    p.right = c;
+
+    c.ht = Math.max(height(c.left), height(c.right)) + 1;
+    p.ht = Math.max(height(p.left), height(p.right)) + 1;
+
+    return p;
+}
+
+static public Node rotatewithright(Node c) {
+    Node p;  // right child of c
+
+    p = c.right;
+    c.right = p.left;
+    p.left = c;
+
+    c.ht = Math.max(height(c.left), height(c.right)) + 1;
+    p.ht = Math.max(height(p.left), height(p.right)) + 1;
+
+    return p;
+}
+
+static public Node doublerotatewithleft(Node c) {
+    Node tmp;
+
+    c.left = rotatewithright(c.left);
+    tmp = rotatewithleft(c);
+
+    return tmp;
+}
+
+static public Node doublerotatewithright(Node c) {
+    Node tmp;
+
+    c.right = rotatewithleft(c.right);
+    tmp = rotatewithright(c);
+
+    return tmp;
+}
+
+static public Node avlinsert(Node newNode, Node par) {
+   Node newpar = par;  // root of subtree par
+
+    if (newNode.val < par.val)  {
+        if (par.left == null) {
+            par.left = newNode;  //attach new node as leaf
+        }
+    else {
+         par.left = avlinsert(newNode, par.left);   // branch left
+         if ((height(par.left) - height(par.right)) == 2) {
+            if (newNode.val < par.left.val) {
+                newpar=rotatewithleft(par);
+            } else {
+                newpar=doublerotatewithleft(par);
+            } //else
+         } //if
+      } // else
+   } // if
+    else if (newNode.val > par.val) { // branch right
+        if (par.right == null) {
+            par.right = newNode;   // attach new node as leaf
+        } else {
+            par.right = avlinsert(newNode, par.right);  // branch right
+            if ((height(par.right) - height(par.left)) == 2) {
+                if (newNode.val > par.right.val) {
+                    newpar=rotatewithright(par);
+                } //if
+                else {
+                    newpar=doublerotatewithright(par);
+                } //else
+            } //if
+        } //else
+    }  // else if
+
+    // Update the height, just in case
+
+    if ((par.left == null) && (par.right != null))
+        par.ht = par.right.ht + 1;
+    else if ((par.right == null) && (par.left != null))
+        par.ht = par.left.ht + 1;
+    else
+        par.ht = Math.max(height(par.left), height(par.right)) + 1;
+
+    return newpar; // return new root of this subtree
+ }

README.md

@@ -1,7 +1,7 @@
 <div align="center">
 <img src="https://github.com/alexprut/HackerRank/raw/master/hackerrank-logo.png" width="450" height="auto"/>
 
-[![Solutions](https://img.shields.io/badge/solutions-408-green.svg?style=flat-square)](https://github.com/alexprut/HackerRank#table-of-contents)
+[![Solutions](https://img.shields.io/badge/solutions-409-green.svg?style=flat-square)](https://github.com/alexprut/HackerRank#table-of-contents)
 [![Languages](https://img.shields.io/badge/languages-c%2B%2B%2Cjava%2Chaskell-yellow.svg)](https://github.com/alexprut/HackerRank#table-of-contents)
 [![Author](https://img.shields.io/badge/author-alexprut-brightgreen.svg?style=flat-square)](https://www.hackerrank.com/alexprut)
 [![MIT](https://img.shields.io/dub/l/vibe-d.svg?style=flat-square)](https://github.com/alexprut/HackerRank/blob/master/LICENSE)
@@ -223,6 +223,7 @@ platform tests of a given problem.
 |Trees|[Binary Search Tree : Lowest Common Ancestor](https://www.hackerrank.com/challenges/binary-search-tree-lowest-common-ancestor)|Easy|30|[Solution.java](Data%20Structures/Trees/Binary%20Search%20Tree%20:%20Lowest%20Common%20Ancestor/Solution.java)|
 |Trees|[Swap Nodes [Algo]](https://www.hackerrank.com/challenges/swap-nodes-algo)|Medium|40|[Solution.java](Data%20Structures/Trees/Swap%20Nodes%20[Algo]/Solution.java)|
 |Trees|[Is This a Binary Search Tree?](https://www.hackerrank.com/challenges/is-binary-search-tree)|Medium|30|[Solution.cpp](Data%20Structures/Trees/Is%20This%20a%20Binary%20Search%20Tree?/Solution.cpp)|
+|Balanced Trees|[Self Balancing Tree](https://www.hackerrank.com/challenges/self-balancing-tree)|Medium|50|[Solution.java](Data%20Structures/Balanced%20Trees/Self%20Balancing%20Tree/Solution.java)|
 |Stacks|[Maximum Element](https://www.hackerrank.com/challenges/maximum-element)|Easy|20|[Solution.java](Data%20Structures/Stacks/Maximum%20Element/Solution.java)|
 |Stacks|[Balanced Brackets](https://www.hackerrank.com/challenges/balanced-brackets)|Medium|25|[Solution.java](Data%20Structures/Stacks/Balanced%20Brackets/Solution.java)|
 |Stacks|[Equal Stacks](https://www.hackerrank.com/challenges/equal-stacks)|Easy|25|[Solution.java](Data%20Structures/Stacks/Equal%20Stacks/Solution.java)|