Added solution to ch4-6 and associated tests.

Author: diadical

src/chapter4/ch4-q06.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Finding the successor as a few different scenarios:
+ *   1. Where a right child exists:
+ *     a. If it has no left child then it is the successor.
+ *     b. If it has a left child then keep following left child pointers until
+ *     you've got the left most child, this is the successor.
+ *   2. Where no right child exists:
+ *     a. If this node is a left child then the successor is its parent.
+ *     b. Otherwise follow parent pointers until we find a node that is a left
+ *     child of its parent, then the parent is the successor.
+ *
+ * N = |tree|
+ * Time: O(lg N)
+ * Additional space: O(1)
+ */
+export function findSuccessor(node) {
+  if (!node) {
+    throw new Error('node cannot be null');
+  }
+
+  let snode;
+  if (node.right) {
+    snode = node.right;
+    while (snode.left) {
+      snode = snode.left;
+    }
+    return snode.val;
+  }
+  else {
+    // go up until we find left path
+    snode = node;
+    while (snode.parent && snode !== snode.parent.left) {
+      snode = snode.parent;
+    }
+    return snode.parent ? snode.parent.val : undefined;
+  }
+}

src/chapter4/ch4-q06.spec.js

@@ -0,0 +1,46 @@
+import { expect } from 'chai';
+import { Tree } from './helpers';
+import * as funcs from './ch4-q06';
+
+for (let key in funcs) {
+  let func = funcs[key];
+
+  describe('ch4-q06: ' + key, function() {
+
+    beforeEach(function() {
+      this.tree = new Tree();
+    });
+
+    it('throws an error if node is null', function() {
+      expect(() => func(null)).to.throw('node cannot be null');
+    });
+
+    it('returns undefined for root of single node tree', function() {
+      this.tree.add(10);
+      expect(func(this.tree.root)).to.be.undefined;
+    });
+
+    it('returns right value for simple 3 node balanced tree', function() {
+      [10, 9, 11].forEach(v => this.tree.add(v));
+      expect(func(this.tree.root.left)).to.equal(10);
+      expect(func(this.tree.root)).to.equal(11);
+      expect(func(this.tree.root.right)).to.be.undefined;
+    });
+
+    it('returns correct values for larger balanced tree', function() {
+      [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15].forEach(v => this.tree.add(v));
+
+      expect(func(this.tree.root.left.left.left)).to.equal(2);
+      expect(func(this.tree.root.left.left.right)).to.equal(4);
+      expect(func(this.tree.root.left.right.left)).to.equal(6);
+      expect(func(this.tree.root.left.right.right)).to.equal(8);
+
+      expect(func(this.tree.root.right.left.left)).to.equal(10);
+      expect(func(this.tree.root.right.left.right)).to.equal(12);
+      expect(func(this.tree.root.right.right.left)).to.equal(14);
+      expect(func(this.tree.root.right.right.right)).to.be.undefined;
+    });
+
+  });
+
+}