Added solution to ch4-11 and associated tests.

Author: diadical

src/chapter4/ch4-q11.js

@@ -0,0 +1,135 @@
+'use strict';
+
+class Node {
+  constructor(value, parent) {
+    this.left = this.right = null;
+    this.parent = parent || null;
+    this.val = value;
+    this.size = 1; // including itself
+  }
+}
+
+/**
+ * RandomNode routine first gets a random number between 1 and the number of
+ * elements in the tree. Every node in the tree keeps track of the size of the
+ * subtree that is it a part of (number of nodes in left and right subtrees
+ * as well as itself). Using these counts we can go through the tree and find
+ * the node whose index would match that random number if the trees values
+ * where considered in order.
+ *
+ * If the random number is:
+ *   1. smaller than the nodes left subtree size then go left.
+ *   2. equal to the left subtree size + 1 then return current node.
+ *   3. otherwise go right and subtract the left subtree size from the random
+ *   	number as we have already skipped over that many values.
+ *
+ * N = |tree|
+ * Time: insert O(lg N), delete O(lg N), find O(lg N), randomNode O(lg N) - this
+ * assumes a balanced tree, otherwise all of these would be O(N) in the worst case
+ * Additional space: insert O(N) - to hold values and keep track of subtree sizes
+ * delete O(lg N), find O(1), randomNode O(1)
+ */
+export class RandomBinarySearchTree {
+  constructor() {
+    this.root = null;
+  }
+
+  insert(value) {
+    let node = this,
+      branch = 'root';
+    while (node[branch]) {
+      node = node[branch];
+      ++node.size;
+      branch = value < node.val ? 'left' : 'right';
+    }
+    node[branch] = new Node(value, node);
+  }
+
+  delete(value) {
+    return this._deleteRecursive(this.root, 'root', value);
+  }
+
+  _deleteRecursive(node, parentBranch, value) {
+    if (node) {
+      if (node.val === value) {
+        if (!node.left && !node.right) {
+          node.parent[parentBranch] = null;
+          return true;
+        }
+        else if (node.left && !node.right) {
+          node.parent[parentBranch] = node.left;
+          return true;
+        }
+        else if (!node.left && node.right) {
+          node.parent[parentBranch] = node.right;
+          return true;
+        }
+        else {
+          let minNode = node.right;
+          while (minNode.left) {
+            minNode = minNode.left;
+          }
+          node.val = minNode.val;
+          --node.size;
+          return this._deleteRecursive(node.right, 'right', minNode.val);
+        }
+      }
+      else {
+        let branch = value < node.val ? 'left' : 'right';
+        if (this._deleteRecursive(node[branch], branch, value)) {
+          --node.size;
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  find(value) {
+    let node = this.root,
+      branch;
+    while (node) {
+      if (node.val === value) {
+        return node;
+      }
+      branch = value < node.val ? 'left' : 'right';
+      node = node[branch];
+    }
+    return undefined;
+  }
+
+  randomNode() {
+    if (!this.root) {
+      return undefined;
+    }
+
+    let idx = Math.ceil(Math.random() * this.root.size),
+      node = this.root;
+    while (idx > 0) {
+      if (node.left) {
+        if (idx === node.left.size + 1) {
+          return node;
+        }
+        else if (idx <= node.left.size) {
+          node = node.left;
+        }
+        else if (node.right) {
+          idx -= node.left.size + 1;
+          node = node.right;
+        }
+      }
+      else {
+        if (idx <= 1) {
+          return node;
+        }
+        else if (node.right) {
+          --idx;
+          node = node.right;
+        }
+      }
+    }
+
+    throw new Error('Should never reach this code, this is just an assertion that we dont');
+  }
+}

src/chapter4/ch4-q11.spec.js

@@ -0,0 +1,90 @@
+import { expect } from 'chai';
+import * as classes from './ch4-q11';
+
+function runSampling(values, obj, samples) {
+  for (let i = 0; i < samples; ++i) {
+    let val = obj.randomNode().val;
+    values[val - 1] = true;
+  }
+}
+
+for (let key in classes) {
+  let Class = classes[key];
+
+  describe('ch4-q11: ' + key, function() {
+
+    beforeEach(function() {
+      this.obj = new Class();
+    });
+
+    it('returns single number when only one item in tree', function() {
+      this.obj.insert(1);
+      expect(this.obj.randomNode().val).to.equal(1);
+      expect(this.obj.randomNode().val).to.equal(1);
+      expect(this.obj.randomNode().val).to.equal(1);
+    });
+
+    [
+      {
+        desc: 'balanced',
+        values: [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
+      },
+      {
+        desc: 'left imbalanced',
+        values: [15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+      },
+      {
+        desc: 'right imbalanced',
+        values: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+      },
+      {
+        desc: 'random',
+        values: [3, 15, 2, 1, 8, 4, 5, 7, 6, 14, 13, 12, 10, 11, 9]
+      }
+    ].forEach(context => {
+
+      describe(`with ${context.desc} tree`, function () {
+
+        beforeEach(function() {
+          context.values.forEach(v => this.obj.insert(v));
+        });
+
+        it('returns random number in range', function() {
+          expect(this.obj.randomNode().val).to.be.within(1, 15);
+        });
+
+        it('returns all numbers in range over 1000 calls', function() {
+          let gotValue = (new Array(15)).fill(false);
+          runSampling(gotValue, this.obj, 1000);
+          expect(gotValue.every(v => v)).to.be.true;
+        });
+
+        it('returns valid numbers in range over 1000 calls where deletions are done', function() {
+          let pickedValues;
+
+          this.obj.delete(1);
+          pickedValues = (new Array(15)).fill(false);
+          runSampling(pickedValues, this.obj, 1000);
+          expect(pickedValues).to.eql([false, true, true, true, true, true, true,
+            true, true, true, true, true, true, true, true]);
+
+          this.obj.delete(8);
+          pickedValues = (new Array(15)).fill(false);
+          runSampling(pickedValues, this.obj, 1000);
+          expect(pickedValues).to.eql([false, true, true, true, true, true, true,
+            false, true, true, true, true, true, true, true]);
+
+          this.obj.delete(12);
+          pickedValues = (new Array(15)).fill(false);
+          runSampling(pickedValues, this.obj, 1000);
+          expect(pickedValues).to.eql([false, true, true, true, true, true, true,
+            false, true, true, true, false, true, true, true]);
+        });
+
+      });
+
+    });
+
+  });
+
+}