merge: Improving the coding standard for AvLTree Data Structure (#882)

* Improving the coding standard for AvLTree Data Structure

* Test case creation for AVLTree

~ Created test cases for AVL Tree
~ Indentation fix for AVLTree.js

* Auto-update DIRECTORY.md

* Change in logic for data list

* Style fix based on standard.js

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>

Author: rahulrajrd

Data-Structures/Tree/AVLTree.js

@@ -17,13 +17,9 @@ let utils;
 (function (_utils) {
   function comparator () {
     return function (v1, v2) {
-      if (v1 < v2) {
-        return -1
-      } else if (v2 < v1) {
-        return 1
-      } else {
-        return 0
-      }
+      if (v1 < v2) return -1
+      if (v2 < v1) return 1
+      return 0
     }
   }
   _utils.comparator = comparator
@@ -39,112 +35,118 @@ const AVLTree = (function () {
   function _avl (comp) {
     /** @public comparator function */
     this._comp = undefined
-    if (comp !== undefined) {
-      this._comp = comp
-    } else {
-      this._comp = utils.comparator()
-    }
+    this._comp = comp !== undefined ? comp : utils.comparator()
+
     /** @public root of the AVL Tree */
     this.root = null
     /** @public number of elements in AVL Tree */
     this.size = 0
   }
+
   // creates new Node Object
   const Node = function (val) {
     this._val = val
     this._left = null
     this._right = null
     this._height = 1
   }
+
   // get height of a node
-  const getH = function (node) {
+  const getHeight = function (node) {
     if (node == null) { return 0 }
     return node._height
   }
+
   // height difference or balance factor of a node
-  const getHDiff = function (node) {
-    if (node == null) { return 0 } else { return getH(node._left) - getH(node._right) }
+  const getHeightDifference = function (node) {
+    return node == null ? 0 : getHeight(node._left) - getHeight(node._right)
   }
+
   // update height of a node based on children's heights
-  const updateH = function (node) {
-    if (node == null) {
-      return
-    }
-    node._height = Math.max(getH(node._left), getH(node._right)) + 1
+  const updateHeight = function (node) {
+    if (node == null) { return }
+    node._height = Math.max(getHeight(node._left), getHeight(node._right)) + 1
   }
+
+  // Helper: To check if the balanceFactor is valid
+  const isValidBalanceFactor = (balanceFactor) => [0, 1, -1].includes(balanceFactor)
+
   // rotations of AVL Tree
   const leftRotate = function (node) {
     const temp = node._right
     node._right = temp._left
     temp._left = node
-    updateH(node)
-    updateH(temp)
+    updateHeight(node)
+    updateHeight(temp)
     return temp
   }
   const rightRotate = function (node) {
     const temp = node._left
     node._left = temp._right
     temp._right = node
-    updateH(node)
-    updateH(temp)
+    updateHeight(node)
+    updateHeight(temp)
     return temp
   }
+
   // check if tree is balanced else balance it for insertion
   const insertBalance = function (node, _val, balanceFactor) {
     if (balanceFactor > 1 && _val < node._left._val) {
       return rightRotate(node) // Left Left Case
-    } else if (balanceFactor < 1 && _val > node._right._val) {
+    }
+    if (balanceFactor < 1 && _val > node._right._val) {
       return leftRotate(node) // Right Right Case
-    } else if (balanceFactor > 1 && _val > node._left._val) {
+    }
+    if (balanceFactor > 1 && _val > node._left._val) {
       node._left = leftRotate(node._left) // Left Right Case
       return rightRotate(node)
     }
     node._right = rightRotate(node._right)
     return leftRotate(node)
   }
+
   // check if tree is balanced after deletion
   const delBalance = function (node) {
-    const balanceFactor1 = getHDiff(node)
-    if (balanceFactor1 === 0 || balanceFactor1 === 1 || balanceFactor1 === -1) {
+    const balanceFactor1 = getHeightDifference(node)
+    if (isValidBalanceFactor(balanceFactor1)) {
       return node
     }
     if (balanceFactor1 > 1) {
-      if (getHDiff(node._left) >= 0) {
+      if (getHeightDifference(node._left) >= 0) {
         return rightRotate(node) // Left Left
       }
       node._left = leftRotate(node._left)
       return rightRotate(node) // Left Right
     }
-    if (getHDiff(node._right) > 0) {
+    if (getHeightDifference(node._right) > 0) {
       node._right = rightRotate(node._right)
       return leftRotate(node) // Right Left
     }
     return leftRotate(node) // Right Right
   }
+
   // implement avl tree insertion
   const insert = function (root, val, tree) {
     if (root == null) {
       tree.size++
       return new Node(val)
-    } else if (tree._comp(root._val, val) < 0) {
+    }
+    if (tree._comp(root._val, val) < 0) {
       root._right = insert(root._right, val, tree)
     } else if (tree._comp(root._val, val) > 0) {
       root._left = insert(root._left, val, tree)
     } else {
       return root
     }
-    updateH(root)
-    const balanceFactor = getHDiff(root)
-    if (balanceFactor === 0 || balanceFactor === 1 || balanceFactor === -1) {
-      return root
-    }
-    return insertBalance(root, val, balanceFactor)
+    updateHeight(root)
+    const balanceFactor = getHeightDifference(root)
+    return isValidBalanceFactor(balanceFactor) ? root : insertBalance(root, val, balanceFactor)
   }
-  // delete a element
-  const del = function (root, _val, tree) {
-    if (root == null) {
-      return root
-    } else if (tree._comp(root._val, _val) === 0) { // key found case
+
+  // delete am element
+  const deleteElement = function (root, _val, tree) {
+    if (root == null) { return root }
+    if (tree._comp(root._val, _val) === 0) { // key found case
       if (root._left === null && root._right === null) {
         root = null
         tree.size--
@@ -160,29 +162,29 @@ const AVLTree = (function () {
           temp = temp._left
         }
         root._val = temp._val
-        root._right = del(root._right, temp._val, tree)
+        root._right = deleteElement(root._right, temp._val, tree)
       }
     } else {
       if (tree._comp(root._val, _val) < 0) {
-        root._right = del(root._right, _val, tree)
+        root._right = deleteElement(root._right, _val, tree)
       } else {
-        root._left = del(root._left, _val, tree)
+        root._left = deleteElement(root._left, _val, tree)
       }
     }
-    updateH(root)
+    updateHeight(root)
     root = delBalance(root)
     return root
   }
   // search tree for a element
-  const search = function (root, val, tree) {
-    if (root == null) {
-      return null
-    } else if (tree._comp(root._val, val) === 0) {
+  const searchAVLTree = function (root, val, tree) {
+    if (root == null) { return null }
+    if (tree._comp(root._val, val) === 0) {
       return root
-    } else if (tree._comp(root._val, val) < 0) {
-      return search(root._right, val, tree)
     }
-    return search(root._left, val, tree)
+    if (tree._comp(root._val, val) < 0) {
+      return searchAVLTree(root._right, val, tree)
+    }
+    return searchAVLTree(root._left, val, tree)
   }
 
   /* Public Functions */
@@ -196,22 +198,16 @@ const AVLTree = (function () {
   _avl.prototype.add = function (_val) {
     const prevSize = this.size
     this.root = insert(this.root, _val, this)
-    if (this.size === prevSize) {
-      return false
-    }
-    return true
+    return this.size !== prevSize
   }
   /**
    * TO check is a particular element exists or not
    * @param {any} _val
    * @returns {Boolean} exists or not
    */
   _avl.prototype.find = function (_val) {
-    const temp = search(this.root, _val, this)
-    if (temp != null) {
-      return true
-    }
-    return false
+    const temp = searchAVLTree(this.root, _val, this)
+    return temp != null
   }
   /**
    *
@@ -222,11 +218,8 @@ const AVLTree = (function () {
    */
   _avl.prototype.remove = function (_val) {
     const prevSize = this.size
-    this.root = del(this.root, _val, this)
-    if (prevSize === this.size) {
-      return false
-    }
-    return true
+    this.root = deleteElement(this.root, _val, this)
+    return prevSize !== this.size
   }
   return _avl
 }())

Data-Structures/Tree/test/AVLTree.test.js

@@ -0,0 +1,30 @@
+import { AVLTree } from '../AVLTree'
+
+describe('AVLTree Implementation: ', () => {
+  const avlTree = new AVLTree()
+  const dataList = []
+  const demoData = [1, 4, 6, 22, 7, 99, 4, 66, 77, 98]
+
+  beforeAll(() => {
+    demoData.forEach(item => {
+      if (avlTree.add(item)) {
+        dataList.push(item)
+      }
+    })
+  })
+
+  it('checks if element is inserted properly', () => {
+    expect(dataList.length).toEqual(avlTree.size)
+  })
+
+  it('search if inserted element is present', () => {
+    demoData.forEach(data => {
+      expect(avlTree.find(data)).toBeTruthy()
+    })
+  })
+
+  it('deletes the inserted element', () => {
+    const deleteElement = dataList[3]
+    expect(avlTree.remove(deleteElement)).toBeTruthy()
+  })
+})