feat(TreeNode): uncle and sibling

Author: amejiarosario

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

@@ -1,4 +1,6 @@
 const BinarySearchTree = require('./binary-search-tree');
+// const TreeNode = require('./tree-node');
+
 /**
  * Red-Black Tree
  *
@@ -23,19 +25,29 @@ class RedBlackBST extends BinarySearchTree {
    * @param {any} value new nodes' value
    */
   add(value) {
+    // add node using the regular BST add
     const node = super.add(value);
 
     if (node === this.root) {
       node.meta.color = RedBlackBST.BLACK;
     } else {
       node.meta.color = RedBlackBST.RED;
-      // this.balance(node);
+      this.balance(node);
     }
 
     return node;
   }
+
+  /**
+   * Balance tree by doing rotations
+   * @param {TreeNode} node
+   */
+  balance(node) {
+
+  }
 }
 
+
 RedBlackBST.RED = Symbol('red');
 RedBlackBST.BLACK = Symbol('black');
 

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

@@ -12,11 +12,18 @@ describe('RedBlackBST', () => {
       expect(redBlackBST).not.toBe(undefined);
     });
 
-    it('should add a node', () => {
-      redBlackBST.add(1);
+    it('should make root black', () => {
+      const root = redBlackBST.add(1);
+      expect(root.meta.color).toBe(RedBlackBST.BLACK);
       expect(redBlackBST.size).toBe(1);
     });
 
+    it('should add a new node as red', () => {
+      redBlackBST.add(1);
+      const n2 = redBlackBST.add(2);
+      expect(n2.meta.color).toBe(RedBlackBST.RED);
+    });
+
     xit('should balance tree by rotating left', () => {
       const n1 = redBlackBST.add(1);
       const n2 = redBlackBST.add(2);

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

@@ -31,6 +31,24 @@ class TreeNode {
     this.descendents[1] = node;
     if (node) { node.parent = this; } // eslint-disable-line  no-param-reassign
   }
+
+  /**
+   * Get sibling of current node
+   */
+  get sibling() {
+    const { parent } = this;
+    if (!parent) return null;
+    return parent.right === this ? parent.left : parent.right;
+  }
+
+  /**
+   * Get parent sibling = uncle (duh)
+   */
+  get uncle() {
+    const { parent } = this;
+    if (!parent) return null;
+    return parent.sibling;
+  }
 }
 
 module.exports = TreeNode;

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

@@ -34,4 +34,41 @@ describe('Tree Node', () => {
     expect(treeNode.right.value).toBe(1);
     expect(newNode.parent).toBe(treeNode);
   });
+
+  describe('Family operations', () => {
+    let g;
+    let p;
+    let u;
+    let c;
+    let s;
+
+    beforeEach(() => {
+      g = new TreeNode('grandparent');
+      p = new TreeNode('parent');
+      u = new TreeNode('uncle');
+      c = new TreeNode('child');
+      s = new TreeNode('sibling');
+
+      g.right = p;
+      g.left = u;
+      p.right = c;
+      p.left = s;
+    });
+
+    it('should get the sibling', () => {
+      expect(c.sibling).toBe(s);
+    });
+
+    it('should get null if no sibling', () => {
+      expect(g.sibling).toBe(null);
+    });
+
+    it('should get the uncle', () => {
+      expect(c.uncle).toBe(u);
+    });
+
+    it('should get null if no uncle', () => {
+      expect(g.uncle).toBe(null);
+    });
+  });
 });