feat(bst) make findNodeAndParent recursive

Author: amejiarosario

README.md

@@ -0,0 +1,17 @@
+
+
+# Tests
+
+Running one test without changing file
+
+```sh
+jest -t '#findNodeAndParent'
+```
+
+Running one test changing code
+
+```js
+  it.only('should return with an element and its parent', () => {
+    // ...
+  });
+```

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

@@ -9,7 +9,7 @@ describe('AvlTree', () => {
 
   describe('#contructor', () => {
     it('should initialize', () => {
-      expect(tree).not.toBe(undefined);
+      expect(tree).not.toBe(null);
     });
   });
 
@@ -68,8 +68,8 @@ describe('AvlTree', () => {
       expect(tree.toArray()).toEqual([
         30,
         20, 40,
-        10, undefined, undefined, 50,
-        undefined, undefined, undefined, undefined,
+        10, null, null, 50,
+        null, null, null, null,
       ]);
 
       expect(tree.find(40).balanceFactor).toBe(-1); // l: 0, r: 1, bf: -1

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

@@ -0,0 +1,12 @@
+const Node = require('./binary-tree-node');
+
+class BinarySearchTree {
+  constructor() {
+    this.root = null;
+    this.size = 0;
+  }
+
+  add(value) {
+
+  }
+}

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

@@ -47,19 +47,13 @@ class BinarySearchTree {
    * @param {any} value Node's value to find
    * @returns {TreeNode} matching node or the previous node where value should go
    */
-  findNodeAndParent(value) {
-    let node = this.root;
-    let parent;
-
-    while (node) {
-      if (node.value === value) {
-        break;
-      }
-      parent = node;
-      node = value >= node.value ? node.right : node.left;
+  findNodeAndParent(value, node = this.root, parent = null) {
+    if (!node || node.value === value) {
+      return { found: node, parent };
+    } else if (value < node.value) {
+      return this.findNodeAndParent(value, node.left, node);
     }
-
-    return { found: node, parent };
+    return this.findNodeAndParent(value, node.right, node);
   }
 
   /**

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

@@ -20,10 +20,10 @@ describe('Binary Search Tree', () => {
         const root = bst.add(5);
         const n = bst.add(1);
         expect(n.toValues()).toMatchObject({
-          value: 1, parent: 5, left: undefined, right: undefined,
+          value: 1, parent: 5, left: null, right: null,
         });
         expect(root.toValues()).toMatchObject({
-          value: 5, parent: null, left: 1, right: undefined,
+          value: 5, parent: null, left: 1, right: null,
         });
         bst.add(10);
         expect(root.toValues()).toMatchObject({
@@ -50,7 +50,7 @@ describe('Binary Search Tree', () => {
         expect(root.left).toBe(n2);
         expect(root.right).toBe(n30);
 
-        expect(n30.left).toBe(undefined);
+        expect(n30.left).toBe(null);
         expect(n30.right).toBe(n40);
       });
 
@@ -68,7 +68,7 @@ describe('Binary Search Tree', () => {
         bst.add(1);
         expect(bst.size).toBe(2);
         expect(root.toValues()).toMatchObject({
-          value: 1, parent: null, left: undefined, right: undefined,
+          value: 1, parent: null, left: null, right: null,
         });
         expect(root.meta.multiplicity).toBe(2);
       });
@@ -78,14 +78,14 @@ describe('Binary Search Tree', () => {
       it('should return falsy for empty tree', () => {
         const { found, parent } = bst.findNodeAndParent(5);
         expect(found).toBe(null);
-        expect(parent).toBe(undefined);
+        expect(parent).toBe(null);
       });
 
       it('should return with a single element', () => {
         bst.add(5);
         const { found, parent } = bst.findNodeAndParent(5);
         expect(found).toMatchObject({ value: 5 });
-        expect(parent).toBe(undefined);
+        expect(parent).toBe(null);
       });
 
       it('should return with an element and its parent', () => {
@@ -100,15 +100,15 @@ describe('Binary Search Tree', () => {
         bst.add(5);
         bst.add(1);
         const { found, parent } = bst.findNodeAndParent(10);
-        expect(found).toBe(undefined);
+        expect(found).toBe(null);
         expect(parent).toMatchObject({ value: 5 });
       });
 
       it('should find future parent of a node that doesnt exist yet', () => {
         bst.add(5);
         bst.add(1);
         const { found, parent } = bst.findNodeAndParent(-1);
-        expect(found).toBe(undefined);
+        expect(found).toBe(null);
         expect(parent).toMatchObject({ value: 1 });
       });
     });
@@ -147,43 +147,43 @@ describe('Binary Search Tree', () => {
       });
 
       it('should NOT find the value 20', () => {
-        expect(bst.find(20)).toBe(undefined);
+        expect(bst.find(20)).toBe(null);
       });
     });
 
     describe('#remove', () => {
       it('should remove a left leaf node', () => {
         expect(n4.left).toBe(n3);
         bst.remove(3);
-        expect(n4.left).toBe(undefined);
+        expect(n4.left).toBe(null);
         expect(bst.size).toBe(6);
       });
 
       it('should remove a right leaf node', () => {
         expect(n30.right).toBe(n40);
         bst.remove(40);
-        expect(n30.right).toBe(undefined);
+        expect(n30.right).toBe(null);
         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,
+          value: 3, left: null, right: null, parent: 4,
         });
         bst.remove(4);
         expect(n3.toValues()).toMatchObject({
-          value: 3, left: undefined, right: undefined, parent: 5,
+          value: 3, left: null, right: null, 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,
+          value: 15, left: null, right: null, parent: 30,
         });
         bst.remove(30);
         expect(n15.toValues()).toMatchObject({
-          value: 15, left: undefined, right: undefined, parent: 10,
+          value: 15, left: null, right: null, parent: 10,
         });
       });
 
@@ -224,10 +224,10 @@ describe('Binary Search Tree', () => {
         expect(bst.toArray()).toEqual([
           30,
           15, 40,
-          5, undefined, undefined, undefined,
-          4, undefined,
-          3, undefined,
-          undefined, undefined]);
+          5, null, null, null,
+          4, null,
+          3, null,
+          null, null]);
 
         expect(bst.size).toBe(6);
       });
@@ -312,8 +312,8 @@ describe('Binary Search Tree', () => {
 
     describe('#toArray', () => {
       it('should serialize the tree as an array', () => {
-        expect(bst.toArray()).toEqual([10, 5, 30, 4, undefined, 15, 40, 3,
-          undefined, undefined, undefined, undefined, undefined, undefined, undefined]);
+        expect(bst.toArray()).toEqual([10, 5, 30, 4, null, 15, 40, 3,
+          null, null, null, null, null, null, null]);
       });
     });
 

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

@@ -0,0 +1,12 @@
+/**
+ * Binary Tree Node
+ */
+class BinaryTreeNode {
+  constructor(value) {
+    this.value = value;
+    this.left = null;
+    this.right = null;
+  }
+}
+
+module.exports = BinaryTreeNode;

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

@@ -10,7 +10,7 @@ describe('RedBlackTree', () => {
 
   describe('#add', () => {
     it('should add and self-balance the tree', () => {
-      expect(tree).not.toBe(undefined);
+      expect(tree).not.toBe(null);
     });
 
     it('should make root black', () => {
@@ -37,7 +37,7 @@ describe('RedBlackTree', () => {
       expect(tree.toArray()).toEqual([
         2,
         1, 3,
-        undefined, undefined, undefined, undefined,
+        null, null, null, null,
       ]);
 
       // verify colors
@@ -54,7 +54,7 @@ describe('RedBlackTree', () => {
       expect(tree.toArray()).toEqual([
         2,
         1, 3,
-        undefined, undefined, undefined, undefined,
+        null, null, null, null,
       ]);
 
       // verify colors
@@ -72,8 +72,8 @@ describe('RedBlackTree', () => {
       expect(tree.toArray()).toEqual([
         2,
         1, 3,
-        undefined, undefined, undefined, 4,
-        undefined, undefined,
+        null, null, null, 4,
+        null, null,
       ]);
 
       expect(tree.root.color).toBe(BLACK);
@@ -97,8 +97,8 @@ describe('RedBlackTree', () => {
       expect(tree.toArray()).toEqual([
         2,
         1, 4,
-        undefined, undefined, 3, 5,
-        undefined, undefined, undefined, undefined,
+        null, null, 3, 5,
+        null, null, null, null,
       ]);
 
       expect(n1.color).toBe(BLACK);

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

@@ -18,7 +18,7 @@ class TreeNode {
   }
 
   get left() {
-    return this.descendents[LEFT];
+    return this.descendents[LEFT] || null;
   }
 
   /**
@@ -34,7 +34,7 @@ class TreeNode {
   }
 
   get right() {
-    return this.descendents[RIGHT];
+    return this.descendents[RIGHT] || null;
   }
 
   /**

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

@@ -24,7 +24,7 @@ describe('Tree Node', () => {
   });
 
   it('should set/get left node', () => {
-    expect(treeNode.left).toBe(undefined);
+    expect(treeNode.left).toBe(null);
     const newNode = new TreeNode(1);
     treeNode.left = newNode;
     expect(treeNode.left.value).toBe(1);
@@ -35,7 +35,7 @@ describe('Tree Node', () => {
   });
 
   it('should set/get right node', () => {
-    expect(treeNode.right).toBe(undefined);
+    expect(treeNode.right).toBe(null);
     const newNode = new TreeNode(1);
     treeNode.right = newNode;