fix(bst): update removed parent

Author: amejiarosario

src/data-structures/trees/binary-search-tree.js

@@ -54,6 +54,30 @@ class BinarySearchTree {
     return undefined;
   }
 
+  /**
+   * Get the node with the max value of subtree: the right-most value.
+   * @param {TreeNode} root subtree's root
+   */
+  getMax(root = this.root) {
+    let current = root;
+    while (current && current.right) {
+      current = current.right;
+    }
+    return current;
+  }
+
+  /**
+   * Get the node with the min value of subtree: the left-most value.
+   * @param {TreeNode} root subtree's root
+   */
+  getMin(root = this.root) {
+    let current = root;
+    while (current && current.left) {
+      current = current.left;
+    }
+    return current;
+  }
+
   /**
    * Remove a node from the tree
    * @returns {boolean} false if not found and true if it was deleted
@@ -65,20 +89,24 @@ class BinarySearchTree {
     const { parent } = found;
 
     if (found === this.root) {
+      // removing root
       this.root = found.right || found.left; // replace root
       this.root.parent = null;
-      // if the root had any left subtree, place it at the end of the new root subtree.
+      // if the root had any left subtree,
+      // place it at the end of the new root subtree.
       if (found.left) {
         const newRootLeftmost = this.getMin(this.root.left);
         newRootLeftmost.left = found.left;
       }
     } else if (parent.left === found) {
+      // removing node on the left
       parent.left = found.right || found.left;
 
       if (found.left) {
         parent.left.left = found.left;
       }
     } else if (parent.right === found) {
+      // removing node on the right
       parent.right = found.right || found.left;
 
       if (found.left) {
@@ -90,50 +118,6 @@ class BinarySearchTree {
     return true;
   }
 
-  /**
-   * Represent Binary Tree as an array.
-   *
-   * Leaf nodes will have two `undefined` descendents.
-   *
-   * The array representation of the binary tree is as follows:
-   *
-   * First element (index=0) is the root.
-   * The following two elements (index=1,2) are descendents of the root: left (a) and right (b).
-   * The next two elements (index=3,4) are the descendents of a
-   * The next two elements (index=5,6) are the descendents of b and so on.
-   *
-   *  0     1            2             3       4        5       6        n
-   * [root, a=root.left, b=root.right, a.left, a.right, b.left, b.right, ...]
-   *
-   * You can also find the parents as follows
-   *
-   * e.g.
-   * Parent 0: children 1,2
-   * Parent 1: children 3,4
-   * Parent 2: children 5,6
-   * Parent 3: children 7,8
-   *
-   * Given any index you can find the parent index with the following formula:
-   *
-   * parent = (index) => Math.floor((index-1)/2)
-   */
-  toArray() {
-    const array = [];
-    const queue = new Queue();
-
-    if (this.root) { queue.add(this.root); }
-
-    while (!queue.isEmpty()) {
-      const current = queue.remove();
-      array.push(current && current.value);
-
-      if (current) { queue.add(current.left); }
-      if (current) { queue.add(current.right); }
-    }
-
-    return array;
-  }
-
   /**
    * Breath-first search for a tree (always starting from the root element).
    *
@@ -206,27 +190,47 @@ class BinarySearchTree {
   }
 
   /**
-   * Get the node with the max value of subtree: the right-most value.
-   * @param {TreeNode} root subtree's root
+   * Represent Binary Tree as an array.
+   *
+   * Leaf nodes will have two `undefined` descendents.
+   *
+   * The array representation of the binary tree is as follows:
+   *
+   * First element (index=0) is the root.
+   * The following two elements (index=1,2) are descendents of the root: left (a) and right (b).
+   * The next two elements (index=3,4) are the descendents of a
+   * The next two elements (index=5,6) are the descendents of b and so on.
+   *
+   *  0     1            2             3       4        5       6        n
+   * [root, a=root.left, b=root.right, a.left, a.right, b.left, b.right, ...]
+   *
+   * You can also find the parents as follows
+   *
+   * e.g.
+   * Parent 0: children 1,2
+   * Parent 1: children 3,4
+   * Parent 2: children 5,6
+   * Parent 3: children 7,8
+   *
+   * Given any index you can find the parent index with the following formula:
+   *
+   * parent = (index) => Math.floor((index-1)/2)
    */
-  getMax(root = this.root) {
-    let current = root;
-    while (current && current.right) {
-      current = current.right;
-    }
-    return current;
-  }
+  toArray() {
+    const array = [];
+    const queue = new Queue();
 
-  /**
-   * Get the node with the min value of subtree: the left-most value.
-   * @param {TreeNode} root subtree's root
-   */
-  getMin(root = this.root) {
-    let current = root;
-    while (current && current.left) {
-      current = current.left;
+    if (this.root) { queue.add(this.root); }
+
+    while (!queue.isEmpty()) {
+      const current = queue.remove();
+      array.push(current && current.value);
+
+      if (current) { queue.add(current.left); }
+      if (current) { queue.add(current.right); }
     }
-    return current;
+
+    return array;
   }
 }
 

src/data-structures/trees/binary-search-tree.spec.js

@@ -129,8 +129,10 @@ describe('Binary Search Tree', () => {
 
       it('should remove the root', () => {
         expect(n30.parent).toBe(root);
+        expect(n5.parent).toBe(root);
         bst.remove(10);
         expect(n30.parent).toBe(null);
+        expect(n5.parent.value).toBe(15);
 
         expect(bst.toArray()).toEqual([
           30,