fix(bst): remove

Author: amejiarosario

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

@@ -56,35 +56,40 @@ class BinarySearchTree {
 
   /**
    * Remove a node from the tree
-   * @param {any} value value to remove from the tree
+   * @returns {boolean} false if not found and true if it was deleted
    */
   remove(value) {
-    let current = this.root;
-    let parent = this.root;
+    const found = this.find(value);
+    if (!found) return false;
 
-    // search for the parent of the element
-    while (current) {
-      if (current.value === value) {
-        if (parent.left.value === value) {
-          // value is on the left side
-          parent.left = current.right || current.left;
-          if (current.left) {
-            parent.left.left = current.left;
-          }
-        } else {
-          // value is on the right side
-          parent.right = current.right || current.left;
-          if (current.left) {
-            parent.right.left = current.left;
-          }
-        }
+    const { parent } = found;
 
-        return true;
+    if (found === this.root) {
+      this.root = found.right || found.left; // replace root
+      // 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;
       }
-      parent = current;
-      current = value >= current.value ? current.right : current.left;
+
+      return true;
     }
-    return false;
+
+    if (parent.left === found) {
+      parent.left = found.right || found.left;
+
+      if (found.left) {
+        parent.left.left = found.left;
+      }
+    } else if (parent.right === found) {
+      parent.right = found.right || found.left;
+
+      if (found.left) {
+        parent.right.left = found.left;
+      }
+    }
+
+    return true;
   }
 
   /**
@@ -203,7 +208,7 @@ class BinarySearchTree {
   }
 
   /**
-   * Get the node with the max value of subtree: the righ-most value.
+   * Get the node with the max value of subtree: the right-most value.
    * @param {TreeNode} root subtree's root
    */
   getMax(root = this.root) {
@@ -215,7 +220,7 @@ class BinarySearchTree {
   }
 
   /**
-   * Get the node with the min value of subtree: the let-most value.
+   * Get the node with the min value of subtree: the left-most value.
    * @param {TreeNode} root subtree's root
    */
   getMin(root = this.root) {

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

@@ -38,6 +38,14 @@ describe('Binary Search Tree', () => {
         expect(n30.left).toBe(undefined);
         expect(n30.right).toBe(n40);
       });
+
+      it('should keep parent reference', () => {
+        bst.add(1);
+        bst.add(2);
+        const n3 = bst.add(3);
+
+        expect(n3.parent.value).toBe(2);
+      });
     });
   });
 
@@ -112,6 +120,18 @@ describe('Binary Search Tree', () => {
       it('should return false when it does not exist', () => {
         expect(bst.remove(4.5)).toBe(false);
       });
+
+      it('should remove the root', () => {
+        bst.remove(10);
+
+        expect(bst.toArray()).toEqual([
+          30,
+          15, 40,
+          5, undefined, undefined, undefined,
+          4, undefined,
+          3, undefined,
+          undefined, undefined]);
+      });
     });
 
     describe('#bfs', () => {

src/data-structures/trees/red-black-bst.js

@@ -1,9 +1,42 @@
 const BinarySearchTree = require('./binary-search-tree');
-
+/**
+ * Red-Black Tree
+ *
+ * Properties:
+ *
+ * 1. Every node is either BLACK or RED.
+ * 2. The root is BLACK.
+ * 3. The null leaves are considered BLACK.
+ * 4. Every RED node has only BLACK children.
+ *    A BLACK node can have BLACK children, however a RED node cannot have RED children.
+ * 5. Every path from the leaves to the root has the same number of BLACK nodes.
+ *
+ *
+ */
 class RedBlackBST extends BinarySearchTree {
-  add(node) {
-    return super.add(node);
+  /**
+   * Insert node in the tree.
+   *
+   * The root is always BLACK.
+   * New nodes are always RED.
+   *
+   * @param {any} value new nodes' value
+   */
+  add(value) {
+    const node = super.add(value);
+
+    if (node === this.root) {
+      node.meta.color = RedBlackBST.BLACK;
+    } else {
+      node.meta.color = RedBlackBST.RED;
+      // this.balance(node);
+    }
+
+    return node;
   }
 }
 
+RedBlackBST.RED = Symbol('red');
+RedBlackBST.BLACK = Symbol('black');
+
 module.exports = RedBlackBST;

src/data-structures/trees/red-black-bst.spec.js

@@ -17,14 +17,22 @@ describe('RedBlackBST', () => {
       expect(redBlackBST.size).toBe(1);
     });
 
-    it('should balance tree', () => {
+    xit('should balance tree by rotating left', () => {
       const n1 = redBlackBST.add(1);
       const n2 = redBlackBST.add(2);
       const n3 = redBlackBST.add(3);
 
-      expect(n1.right.value).toBe(2);
+      // expect(n1.right.value).toBe(2);
+      // expect(n2.right.value).toBe(3);
+      // expect(n3.right).toBe(undefined);
+
+      // expect(n1.right.value).toBe(2);
+      expect(n2.left.value).toBe(1);
       expect(n2.right.value).toBe(3);
       expect(n3.right).toBe(undefined);
+      expect(n3.left).toBe(undefined);
+      expect(n1.right).toBe(undefined);
+      expect(n1.left).toBe(undefined);
 
       expect(redBlackBST.size).toBe(3);
     });

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

@@ -2,22 +2,34 @@ class TreeNode {
   constructor(value) {
     this.value = value;
     this.descendents = [];
+    this.parent = null;
+    this.meta = {};
   }
 
   get left() {
     return this.descendents[0];
   }
 
-  set left(value) {
-    this.descendents[0] = value;
+  /**
+   * Set a left node descendents.
+   * Also, children get associated to parent.
+   */
+  set left(node) {
+    this.descendents[0] = node;
+    if (node) { node.parent = this; } // eslint-disable-line  no-param-reassign
   }
 
   get right() {
     return this.descendents[1];
   }
 
-  set right(value) {
-    this.descendents[1] = value;
+  /**
+   * Set a right node descendents.
+   * Also, children get associated to parent.
+   */
+  set right(node) {
+    this.descendents[1] = node;
+    if (node) { node.parent = this; } // eslint-disable-line  no-param-reassign
   }
 }
 

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

@@ -7,19 +7,31 @@ describe('Tree Node', () => {
     treeNode = new TreeNode('hola');
   });
 
+  it('should start with null parent', () => {
+    expect(treeNode.parent).toBe(null);
+  });
+
+  it('should start with empty metadata', () => {
+    expect(treeNode.meta).toEqual({});
+  });
+
   it('should hold a value', () => {
     expect(treeNode.value).toBe('hola');
   });
 
   it('should set/get left node', () => {
     expect(treeNode.left).toBe(undefined);
-    treeNode.left = 1;
-    expect(treeNode.left).toBe(1);
+    const newNode = new TreeNode(1);
+    treeNode.left = newNode;
+    expect(treeNode.left.value).toBe(1);
+    expect(newNode.parent).toBe(treeNode);
   });
 
   it('should set/get right node', () => {
     expect(treeNode.right).toBe(undefined);
-    treeNode.right = 1;
-    expect(treeNode.right).toBe(1);
+    const newNode = new TreeNode(1);
+    treeNode.right = newNode;
+    expect(treeNode.right.value).toBe(1);
+    expect(newNode.parent).toBe(treeNode);
   });
 });