🚧 progress: First draft without explicit leaves.

Everything went as planned except that we needed to mock the child of
the deleted node when it is an implicit leaf.

The losses:
This change puts additional load on:
  - delete_case{3,4,5},
  - insert_case3, and
  - rotate_{left,right}

This load comes from nullchecks before color checks and parent
assignments.
These checks should only be needed at the lowest levels of the fixed
path because of the red-black tree properties.
They could perhaps be circumvented entirely by adding additional mocked
leaves to the sibling of the child of the deleted node. This should
somehow be amortized by the facts that there is at most one deletion per
node created and that each node now costs less to create (because of the
allowed null pointers, see gains).
If property access is always preceded by a nullcheck and if an explicit
preceding nullcheck is somehow optimized away by the compiler, then perhaps
nothing needs to be done. We have to profile this.

The gains:
  - all Leaf children are replaced by null (>1/6 space save)
  - all isLeaf() calls are replaced by nullchecks: really faster? Should
    be since I assume each method call must be preceded by a null check
    internally?

Also we should rewrite delete_one_child to completely avoid this mocking
in case the deleted node is red. I left a TODO note about this.

This is progress on #104.

Author: make-github-pseudonymous-again

mangle.json

@@ -2,14 +2,13 @@
   "minify": {
     "mangle": {
       "properties": {
-        "regex": "^(_color|isLeaf)$"
+        "regex": "^_color$"
       }
     }
   },
   "props": {
     "props": {
-      "$_color": "c",
-      "$isLeaf": "L"
+      "$_color": "c"
     }
   }
 }

src/debug/_debug.js

@@ -1,6 +1,5 @@
 import assert from 'assert';
 import Node from '../types/Node.js';
-import Leaf from '../types/Leaf.js';
 import BLACK from '../color/BLACK.js';
 
 /**
@@ -14,15 +13,11 @@ const _debug = ({red, black}) => {
 	 * Recursively constructs a prettyprint string for the red-black tree rooted at
 	 * <code>root</code>.
 	 *
-	 * @param {Node|Leaf} root - The root of the tree.
+	 * @param {Node} root - The root of the tree.
 	 * @returns {string}
 	 */
 	const debug = (root) => {
-		assert(root instanceof Node || root instanceof Leaf);
-		if (root.isLeaf()) {
-			assert(root instanceof Leaf);
-			return black('L');
-		}
+		if (root === null) return black('L');
 
 		assert(root instanceof Node);
 

src/deletion/delete_case2.js

@@ -25,6 +25,7 @@ const delete_case2 = (n) => {
 	assert(n.parent !== null);
 
 	const s = sibling(n);
+	assert(s instanceof Node);
 
 	/**
 	 * If n's sibling is red, prepare for and go to case 4.

src/deletion/delete_case3.js

@@ -34,15 +34,15 @@ const delete_case3 = (n) => {
 	 *           B                      >B
 	 *         /   \                  /     \
 	 *      >B       B               B       R
-	 *      / \     / \     -->    /   \    / \
-	 *     -   -  B     B         -     - B     B
+	 *      / \     / \     -->     / \     / \
+	 *     -   -  B     B          -   -  B     B
 	 *           / \   / \               / \   / \
 	 *          -   - -   -             -   - -   -
 	 */
 	if (
 		n.parent._color === BLACK &&
-		s.left._color === BLACK &&
-		s.right._color === BLACK
+		(s.left === null || s.left._color === BLACK) &&
+		(s.right === null || s.right._color === BLACK)
 	) {
 		s._color = RED;
 		delete_case1(n.parent);

src/deletion/delete_case4.js

@@ -26,7 +26,9 @@ const delete_case4 = (n) => {
 	assert(s instanceof Node);
 	assert(s._color === BLACK);
 	assert(
-		n.parent._color === RED || s.left._color === RED || s.right._color === RED,
+		n.parent._color === RED ||
+			s.left?._color === RED ||
+			s.right?._color === RED,
 	);
 
 	/**
@@ -46,8 +48,8 @@ const delete_case4 = (n) => {
 	if (
 		// The parent color test is always true when coming from case 2
 		n.parent._color === RED &&
-		s.left._color === BLACK &&
-		s.right._color === BLACK
+		(s.left === null || s.left._color === BLACK) &&
+		(s.right === null || s.right._color === BLACK)
 	) {
 		s._color = RED;
 		n.parent._color = BLACK;

src/deletion/delete_case5.js

@@ -27,7 +27,7 @@ const delete_case5 = (n) => {
 	const s = sibling(n);
 	assert(s instanceof Node);
 	assert(s._color === BLACK);
-	assert(s.left._color === RED || s.right._color === RED);
+	assert(s.left?._color === RED || s.right?._color === RED);
 
 	// The following statements just force the red n's sibling child to be on
 	// the left of the left of the parent, or right of the right, so case 6
@@ -44,11 +44,14 @@ const delete_case5 = (n) => {
 	 *                                            / \
 	 *                                           -   -
 	 */
-	if (n === n.parent.left && s.right._color === BLACK) {
+	if (n === n.parent.left && (s.right === null || s.right._color === BLACK)) {
 		s._color = RED;
 		s.left._color = BLACK;
 		rotate_right(s);
-	} else if (n === n.parent.right && s.left._color === BLACK) {
+	} else if (
+		n === n.parent.right &&
+		(s.left === null || s.left._color === BLACK)
+	) {
 		/**
 		 *           ?                       ?
 		 *         /   \                  /     \

src/deletion/delete_mocked_leaf.js

@@ -0,0 +1,17 @@
+import assert from 'assert';
+import Leaf from '../types/Leaf.js';
+
+/**
+ * Delete leaf L.
+ *
+ * @param {Leaf} L - The leaf to delete.
+ */
+const delete_mocked_leaf = (L) => {
+	assert(L instanceof Leaf);
+	assert(L.parent !== null);
+
+	if (L === L.parent.left) L.parent.left = null;
+	else L.parent.right = null;
+};
+
+export default delete_mocked_leaf;

src/deletion/delete_one_child.js

@@ -7,6 +7,8 @@ import Leaf from '../types/Leaf.js';
 import replace_node from './replace_node.js';
 import delete_case2 from './delete_case2.js';
 
+import delete_mocked_leaf from './delete_mocked_leaf.js';
+
 /**
  * Delete a node <code>n</code> that has at most a single non-leaf child.
  *
@@ -25,9 +27,12 @@ const delete_one_child = (n) => {
 	// The right child of n is always a LEAF because either n is a subtree
 	// predecessor or it is the only child of its parent by the red-black tree
 	// properties
-	assert(n.right instanceof Leaf);
+	assert(n.right === null);
+
+	// Mock leaf if there is no left child
+	const child = n.left === null ? new Leaf(null) : n.left;
 
-	const child = n.left;
+	// TODO skip creating mocked leaf if n._color === RED
 
 	// Replace n with its left child
 	replace_node(n, child);
@@ -48,6 +53,8 @@ const delete_one_child = (n) => {
 		//    child suffices. This is a NO-OP.
 		assert(child._color === BLACK);
 	}
+
+	if (child instanceof Leaf) delete_mocked_leaf(child);
 };
 
 export default delete_one_child;

src/family/predecessor.js

@@ -12,7 +12,7 @@ const predecessor = (node) => {
 	assert(node.left instanceof Node);
 	let pred = node.left;
 
-	while (!pred.right.isLeaf()) {
+	while (pred.right !== null) {
 		assert(pred.right instanceof Node);
 		pred = pred.right;
 	}

src/family/sibling.js

@@ -6,11 +6,11 @@ import Leaf from '../types/Leaf.js';
  * Computes the sibling of the input node.
  *
  * @param {Node|Leaf} node - The input node.
- * @returns {Node|Leaf}
+ * @returns {Node}
  */
 const sibling = (node) => {
 	assert(node instanceof Node || node instanceof Leaf);
-	// We only use this function when node HAS a sibling.
+	// We only use this function when node HAS a non-leaf sibling.
 	assert(node.parent !== null);
 
 	return node === node.parent.left ? node.parent.right : node.parent.left;

src/family/uncle.js

@@ -1,22 +1,19 @@
 import assert from 'assert';
 import Node from '../types/Node.js';
-import Leaf from '../types/Leaf.js';
 import grandparent from './grandparent.js';
 
 /**
  * Computes the uncle of the input node when the grandparent is guaranteed to
  * exist.
  *
  * @param {Node} node - The input node.
- * @returns {Node|Leaf}
+ * @returns {Node}
  */
 const uncle = (node) => {
 	assert(node instanceof Node);
 	const g = grandparent(node);
 	assert(g !== null);
-	const u = node.parent === g.left ? g.right : g.left;
-	assert(u instanceof Node || u instanceof Leaf);
-	return u;
+	return node.parent === g.left ? g.right : g.left;
 };
 
 export default uncle;

src/insertion/insert.js

@@ -22,7 +22,7 @@ const insert = (compare, A, B) => {
 		if (compare(B.key, A.key) < 0) {
 			const node = A.left;
 
-			if (node.isLeaf()) {
+			if (node === null) {
 				A.left = B;
 				break;
 			}
@@ -32,7 +32,7 @@ const insert = (compare, A, B) => {
 		} else {
 			const node = A.right;
 
-			if (node.isLeaf()) {
+			if (node === null) {
 				A.right = B;
 				break;
 			}

src/insertion/insert_case2.js

@@ -15,8 +15,8 @@ import insert_case3 from './insert_case3.js';
 const insert_case2 = (n) => {
 	assert(n instanceof Node);
 	assert(n._color === RED);
-	assert(n.left._color === BLACK);
-	assert(n.right._color === BLACK);
+	assert(n.left === null || n.left._color === BLACK);
+	assert(n.right === null || n.right._color === BLACK);
 	assert(n.parent !== null);
 
 	/**

src/insertion/insert_case3.js

@@ -19,8 +19,8 @@ import insert_case4 from './insert_case4.js';
 const insert_case3 = (n) => {
 	assert(n instanceof Node);
 	assert(n._color === RED);
-	assert(n.left._color === BLACK);
-	assert(n.right._color === BLACK);
+	assert(n.left === null || n.left._color === BLACK);
+	assert(n.right === null || n.right._color === BLACK);
 	assert(n.parent !== null);
 	assert(n.parent._color === RED);
 	const u = uncle(n);
@@ -39,7 +39,7 @@ const insert_case3 = (n) => {
 	 *     -   -                 -   -
 	 */
 
-	if (u._color === RED) {
+	if (u !== null && u._color === RED) {
 		n.parent._color = BLACK;
 		u._color = BLACK;
 		const g = grandparent(n);

src/insertion/insert_case4.js

@@ -22,8 +22,8 @@ import insert_case5 from './insert_case5.js';
 const insert_case4 = (n) => {
 	assert(n instanceof Node);
 	assert(n._color === RED);
-	assert(n.left._color === BLACK);
-	assert(n.right._color === BLACK);
+	assert(n.left === null || n.left._color === BLACK);
+	assert(n.right === null || n.right._color === BLACK);
 	assert(n.parent !== null);
 	assert(n.parent._color === RED);
 	const g = grandparent(n);

src/insertion/insert_case5.js

@@ -20,8 +20,8 @@ import grandparent from '../family/grandparent.js';
 const insert_case5 = (n) => {
 	assert(n instanceof Node);
 	assert(n._color === RED);
-	assert(n.left._color === BLACK);
-	assert(n.right._color === BLACK);
+	assert(n.left === null || n.left._color === BLACK);
+	assert(n.right === null || n.right._color === BLACK);
 	assert(n.parent !== null);
 	assert(n.parent._color === RED);
 	const g = grandparent(n);
@@ -45,7 +45,7 @@ const insert_case5 = (n) => {
 		 */
 		assert(g.left instanceof Node);
 		assert(n === g.left.left);
-		assert(g.right._color === BLACK);
+		assert(g.right === null || g.right._color === BLACK);
 		rotate_right(g);
 	} else {
 		/**
@@ -62,7 +62,7 @@ const insert_case5 = (n) => {
 		 */
 		assert(g.right instanceof Node);
 		assert(n === g.right.right);
-		assert(g.left._color === BLACK);
+		assert(g.left === null || g.left._color === BLACK);
 		rotate_left(g);
 	}
 };

src/rotate/rotate_left.js

@@ -33,9 +33,9 @@ const rotate_left = (A) => {
 	B.left = a;
 	B.right = b;
 
-	a.parent = B;
-	b.parent = B;
-	c.parent = A;
+	if (a !== null) a.parent = B;
+	if (b !== null) b.parent = B;
+	if (c !== null) c.parent = A;
 };
 
 export default rotate_left;

src/rotate/rotate_right.js

@@ -33,9 +33,9 @@ const rotate_right = (B) => {
 	A.left = b;
 	A.right = c;
 
-	a.parent = B;
-	b.parent = A;
-	c.parent = A;
+	if (a !== null) a.parent = B;
+	if (b !== null) b.parent = A;
+	if (c !== null) c.parent = A;
 };
 
 export default rotate_right;

src/search/search.js

@@ -18,14 +18,11 @@ const search = (compare, root, key) => {
 			return root;
 		}
 
-		const child = d < 0 ? root.left : root.right;
+		root = d < 0 ? root.left : root.right;
 
-		if (child.isLeaf()) {
+		if (root === null) {
 			return null;
 		}
-
-		assert(child instanceof Node);
-		root = child;
 	}
 };
 

src/traversal/inordertraversal.js

@@ -9,7 +9,7 @@ import Node from '../types/Node.js';
  */
 export default function* inordertraversal(node) {
 	assert(node instanceof Node);
-	if (!node.left.isLeaf()) {
+	if (node.left !== null) {
 		// Yield the nodes on the left recursively. Those nodes are all smaller
 		// than (or equal to) the current node by the binary search tree
 		// properties.
@@ -20,7 +20,7 @@ export default function* inordertraversal(node) {
 	// Yield the current node.
 	yield node.key;
 
-	if (!node.right.isLeaf()) {
+	if (node.right !== null) {
 		// Yield the nodes on the right recursively. Those nodes are all larger
 		// than (or equal to) the current node by the binary search tree
 		// properties.

src/traversal/rangetraversal.js

@@ -15,27 +15,27 @@ export default function* rangetraversal(compare, root, left, right) {
 	if (compare(root.key, left) < 0) {
 		// If the root lies to the left of the interval, we can discard the
 		// entire left subtree.
-		if (!root.right.isLeaf()) {
+		if (root.right !== null) {
 			assert(root.right instanceof Node);
 			yield* rangetraversal(compare, root.right, left, right);
 		}
 	} else if (compare(root.key, right) >= 0) {
 		// If the root lies to the right of the interval, we can discard the
 		// entire right subtree.
-		if (!root.left.isLeaf()) {
+		if (root.left !== null) {
 			assert(root.left instanceof Node);
 			yield* rangetraversal(compare, root.left, left, right);
 		}
 	} else {
 		// Otherwise just recurse on both subtrees and yield the root in
 		// between.
-		if (!root.left.isLeaf()) {
+		if (root.left !== null) {
 			assert(root.left instanceof Node);
 			yield* rangetraversal(compare, root.left, left, right);
 		}
 
 		yield root.key;
-		if (!root.right.isLeaf()) {
+		if (root.right !== null) {
 			assert(root.right instanceof Node);
 			yield* rangetraversal(compare, root.right, left, right);
 		}