♻️ refactor(rangetraversal): Avoid unnecessary comparisons.

Author: make-github-pseudonymous-again

src/index.js

@@ -30,6 +30,8 @@ export {default as swap_color} from './swap/swap_color.js';
 export {default as swap_left} from './swap/swap_left.js';
 export {default as swap_non_adjacent} from './swap/swap_non_adjacent.js';
 export {default as inordertraversal} from './traversal/inordertraversal.js';
+export {default as leftOpenRangeTraversal} from './traversal/leftOpenRangeTraversal.js';
 export {default as rangetraversal} from './traversal/rangetraversal.js';
+export {default as rightOpenRangeTraversal} from './traversal/rightOpenRangeTraversal.js';
 export {default as Node} from './types/Node.js';
 export {default as RedBlackTree} from './types/RedBlackTree.js';

src/traversal/leftOpenRangeTraversal.js

@@ -0,0 +1,36 @@
+import assert from 'assert';
+import Node from '../types/Node.js';
+import inordertraversal from './inordertraversal.js';
+
+/**
+ * Yields all the keys in the tree rooted at <code>root</code> that lie in the
+ * interval <code>(-oo, right[</code>, in order.
+ *
+ * @param {Function} compare - The comparison function.
+ * @param {Node} root - The root of the tree.
+ * @param {any} right - The non-inclusive upper bound of the interval.
+ * @returns {IterableIterator}
+ */
+export default function* leftOpenRangeTraversal(compare, root, right) {
+	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 !== null) {
+			assert(root.left instanceof Node);
+			yield* leftOpenRangeTraversal(compare, root.left, right);
+		}
+	} else {
+		// Otherwise yield entire left subtree, yield the root, and recurse on
+		// the right subtree.
+		if (root.left !== null) {
+			assert(root.left instanceof Node);
+			yield* inordertraversal(root.left);
+		}
+
+		yield root.key;
+		if (root.right !== null) {
+			assert(root.right instanceof Node);
+			yield* leftOpenRangeTraversal(compare, root.right, right);
+		}
+	}
+}

src/traversal/rangetraversal.js

@@ -1,5 +1,7 @@
 import assert from 'assert';
 import Node from '../types/Node.js';
+import leftOpenRangeTraversal from './leftOpenRangeTraversal.js';
+import rightOpenRangeTraversal from './rightOpenRangeTraversal.js';
 
 /**
  * Yields all the keys in the tree rooted at <code>root</code> that lie in the
@@ -31,13 +33,13 @@ export default function* rangetraversal(compare, root, left, right) {
 		// between.
 		if (root.left !== null) {
 			assert(root.left instanceof Node);
-			yield* rangetraversal(compare, root.left, left, right);
+			yield* rightOpenRangeTraversal(compare, root.left, left);
 		}
 
 		yield root.key;
 		if (root.right !== null) {
 			assert(root.right instanceof Node);
-			yield* rangetraversal(compare, root.right, left, right);
+			yield* leftOpenRangeTraversal(compare, root.right, right);
 		}
 	}
 }

src/traversal/rightOpenRangeTraversal.js

@@ -0,0 +1,36 @@
+import assert from 'assert';
+import Node from '../types/Node.js';
+import inordertraversal from './inordertraversal.js';
+
+/**
+ * Yields all the keys in the tree rooted at <code>root</code> that lie in the
+ * interval <code>[left, +oo)</code>, in order.
+ *
+ * @param {Function} compare - The comparison function.
+ * @param {Node} root - The root of the tree.
+ * @param {any} left - The inclusive lower bound of the interval.
+ * @returns {IterableIterator}
+ */
+export default function* rightOpenRangeTraversal(compare, root, left) {
+	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 !== null) {
+			assert(root.right instanceof Node);
+			yield* rightOpenRangeTraversal(compare, root.right, left);
+		}
+	} else {
+		// Otherwise recurse on left subtree, yield the root, and yield the
+		// entire right subtree.
+		if (root.left !== null) {
+			assert(root.left instanceof Node);
+			yield* rightOpenRangeTraversal(compare, root.left, left);
+		}
+
+		yield root.key;
+		if (root.right !== null) {
+			assert(root.right instanceof Node);
+			yield* inordertraversal(root.right);
+		}
+	}
+}