fix(bst): deleting nodes with subtrees

Author: amejiarosario

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

@@ -17,9 +17,9 @@ class BinarySearchTree {
     const newNode = new TreeNode(value);
 
     if (this.root) {
-      const { node, parent } = this.findNodeAndParent(value);
-      if (node) { // duplicated: value already exist on the tree
-        node.meta.multiplicity = (node.meta.multiplicity || 1) + 1;
+      const { found, parent } = this.findNodeAndParent(value);
+      if (found) { // duplicated: value already exist on the tree
+        found.meta.multiplicity = (found.meta.multiplicity || 1) + 1;
       } else if (value < parent.value) {
         parent.left = newNode;
       } else {
@@ -38,7 +38,7 @@ class BinarySearchTree {
    * @param {any} value value to find
    */
   find(value) {
-    return this.findNodeAndParent(value).node;
+    return this.findNodeAndParent(value).found;
   }
 
   /**
@@ -59,7 +59,7 @@ class BinarySearchTree {
       node = value >= node.value ? node.right : node.left;
     }
 
-    return { node, parent };
+    return { found: node, parent };
   }
 
   /**
@@ -94,38 +94,52 @@ class BinarySearchTree {
     const found = this.find(value);
     if (!found) return false;
 
-    const { parent } = found;
+    // Combine left and right children into one subtree.
+    const newSubtree = this.combineLeftIntoRightSubtree(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 (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) {
-        parent.right.left = found.left;
-      }
+      // Replace (root) node to delete with the combined subtree.
+      this.root = newSubtree;
+      this.root.parent = null; // clearing up old parent
+    } else {
+      const side = found.isParentLeftChild ? 'left' : 'right';
+      const { parent } = found; // get parent
+      // Replace node to delete with the combined subtree.
+      parent[side] = newSubtree;
     }
 
     this.size -= 1;
     return true;
   }
 
+  /**
+   * Combine left children/subtree into right children/subtree.
+   *
+   * @example combineLeftIntoRightSubtree(30)
+   *
+   *      30*                             40
+   *    /     \                          /  \
+   *   10      40      combined        35   50
+   *     \    /  \    ---------->     /
+   *     15  35   50                 10
+   *                                   \
+   *                                    15
+   *
+   * It takes node 30 left subtree (10 and 15) and put it in the
+   * leftmost node of the right subtree (40, 35, 50).
+   *
+   * @param {TreeNode} node
+   * @returns {TreeNode} combined subtree
+   */
+  combineLeftIntoRightSubtree(node) {
+    if (node.right) {
+      const leftmost = this.getLeftmost(node.right);
+      leftmost.left = node.left;
+      return node.right;
+    }
+    return node.left;
+  }
+
   /**
    * Breath-first search for a tree (always starting from the root element).
    *
@@ -245,4 +259,12 @@ class BinarySearchTree {
   }
 }
 
+// aliases
+BinarySearchTree.prototype.insert = BinarySearchTree.prototype.add;
+BinarySearchTree.prototype.delete = BinarySearchTree.prototype.remove;
+BinarySearchTree.prototype.getLeftmost = BinarySearchTree.prototype.getMin;
+BinarySearchTree.prototype.minimum = BinarySearchTree.prototype.getMin;
+BinarySearchTree.prototype.getRightmost = BinarySearchTree.prototype.getMax;
+BinarySearchTree.prototype.maximum = BinarySearchTree.prototype.getMax;
+
 module.exports = BinarySearchTree;

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

@@ -76,39 +76,39 @@ describe('Binary Search Tree', () => {
 
     describe('#findNodeAndParent', () => {
       it('should return falsy for empty tree', () => {
-        const { node, parent } = bst.findNodeAndParent(5);
-        expect(node).toBe(null);
+        const { found, parent } = bst.findNodeAndParent(5);
+        expect(found).toBe(null);
         expect(parent).toBe(undefined);
       });
 
       it('should return with a single element', () => {
         bst.add(5);
-        const { node, parent } = bst.findNodeAndParent(5);
-        expect(node).toMatchObject({ value: 5 });
+        const { found, parent } = bst.findNodeAndParent(5);
+        expect(found).toMatchObject({ value: 5 });
         expect(parent).toBe(undefined);
       });
 
       it('should return with an element and its parent', () => {
         bst.add(5);
         bst.add(1);
-        const { node, parent } = bst.findNodeAndParent(1);
-        expect(node).toMatchObject({ value: 1 });
+        const { found, parent } = bst.findNodeAndParent(1);
+        expect(found).toMatchObject({ value: 1 });
         expect(parent).toMatchObject({ value: 5 });
       });
 
       it('should find future parent of a node that doesnt exist yet', () => {
         bst.add(5);
         bst.add(1);
-        const { node, parent } = bst.findNodeAndParent(10);
-        expect(node).toBe(undefined);
+        const { found, parent } = bst.findNodeAndParent(10);
+        expect(found).toBe(undefined);
         expect(parent).toMatchObject({ value: 5 });
       });
 
       it('should find future parent of a node that doesnt exist yet', () => {
         bst.add(5);
         bst.add(1);
-        const { node, parent } = bst.findNodeAndParent(-1);
-        expect(node).toBe(undefined);
+        const { found, parent } = bst.findNodeAndParent(-1);
+        expect(found).toBe(undefined);
         expect(parent).toMatchObject({ value: 1 });
       });
     });
@@ -121,6 +121,7 @@ describe('Binary Search Tree', () => {
     let n5;
     let n30;
     let n40;
+    let n15;
 
     beforeEach(() => {
       //           10
@@ -134,7 +135,7 @@ describe('Binary Search Tree', () => {
       n5 = bst.add(5);
       n30 = bst.add(30);
       n40 = bst.add(40);
-      bst.add(15);
+      n15 = bst.add(15);
       n4 = bst.add(4);
       n3 = bst.add(3);
     });
@@ -165,6 +166,27 @@ describe('Binary Search Tree', () => {
         expect(bst.size).toBe(6);
       });
 
+      it('should remove a child with one descent on the left', () => {
+        expect(n3.toValues()).toMatchObject({
+          value: 3, left: undefined, right: undefined, parent: 4,
+        });
+        bst.remove(4);
+        expect(n3.toValues()).toMatchObject({
+          value: 3, left: undefined, right: undefined, parent: 5,
+        });
+      });
+
+      it('should remove a child with one descent on the right', () => {
+        bst.remove(40);
+        expect(n15.toValues()).toMatchObject({
+          value: 15, left: undefined, right: undefined, parent: 30,
+        });
+        bst.remove(30);
+        expect(n15.toValues()).toMatchObject({
+          value: 15, left: undefined, right: undefined, parent: 10,
+        });
+      });
+
       it('should remove a parent with two descents on the right', () => {
         expect(root.left.value).toBe(5);
         expect(root.right.value).toBe(30);

src/data-structures/trees/tree-node.js

@@ -49,6 +49,19 @@ class TreeNode {
     }
   }
 
+  /**
+   * Tell if is parent's left or right child
+   *
+   * @returns {string} side (left or right) this node is of its parent
+   */
+  get parentChildSide() {
+    if (this.parent) {
+      return this.isParentLeftChild ? 'left' : 'right';
+    }
+
+    return 'root';
+  }
+
   /**
    * Return true if this node is its parent left child
    */