Move new BST functions to unstable

Author: WWRS

data_structures/_binary_search_tree_internals.ts

@@ -24,8 +24,6 @@ export const internals: {
   findNode<T>(
     tree: BinarySearchTree<T>,
     value: T,
-    select?: "higher" | "lower",
-    returnIfFound?: boolean,
   ): BinarySearchNode<T> | null;
   rotateNode<T>(
     tree: BinarySearchTree<T>,

data_structures/binary_search_tree.ts

@@ -125,10 +125,7 @@ export class BinarySearchTree<T> implements Iterable<T> {
     internals.findNode = <T>(
       tree: BinarySearchTree<T>,
       value: T,
-      select?: "higher" | "lower",
-      returnIfFound?: boolean,
-    ): BinarySearchNode<T> | null =>
-      tree.#findNode(value, select, returnIfFound);
+    ): BinarySearchNode<T> | null => tree.#findNode(value);
     internals.rotateNode = <T>(
       tree: BinarySearchTree<T>,
       node: BinarySearchNode<T>,
@@ -322,49 +319,15 @@ export class BinarySearchTree<T> implements Iterable<T> {
     return this.#size;
   }
 
-  /**
-   * Finds the node matching the given selection criteria.
-   *
-   * When searching for higher nodes, returns the lowest node that is higher than
-   * the value. When searching for lower nodes, returns the highest node that is
-   * lower than the value.
-   *
-   * By default, only accepts a node exactly matching the passed value and returns
-   * it if found.
-   *
-   * @param value The value to search for
-   * @param select Whether to accept nodes that are higher or lower than the value
-   * @param returnIfFound Whether a node matching the value itself is accepted
-   * @returns The node that matched, or null if none matched
-   */
-  #findNode(
-    value: T,
-    select?: "higher" | "lower",
-    returnIfFound: boolean = true,
-  ): BinarySearchNode<T> | null {
+  #findNode(value: T): BinarySearchNode<T> | null {
     let node: BinarySearchNode<T> | null = this.#root;
-    let result: BinarySearchNode<T> | null = null;
     while (node) {
-      const order = this.#compare(value, node.value);
-      if (order === 0 && returnIfFound) return node;
-
-      let direction: Direction = order < 0 ? "left" : "right";
-      if (select === "higher" && order === 0) {
-        direction = "right";
-      } else if (select === "lower" && order === 0) {
-        direction = "left";
-      }
-
-      if (
-        (select === "higher" && direction === "left") ||
-        (select === "lower" && direction === "right")
-      ) {
-        result = node;
-      }
-
+      const order: number = this.#compare(value as T, node.value);
+      if (order === 0) break;
+      const direction: "left" | "right" = order < 0 ? "left" : "right";
       node = node[direction];
     }
-    return result;
+    return node;
   }
 
   #rotateNode(node: BinarySearchNode<T>, direction: Direction) {
@@ -525,114 +488,6 @@ export class BinarySearchTree<T> implements Iterable<T> {
     return this.#findNode(value)?.value ?? null;
   }
 
-  /**
-   * Finds the lowest (leftmost) value in the binary search tree which is
-   * greater than or equal to the given value, or null if the given value
-   * is higher than all elements of the tree.
-   *
-   * The complexity of this operation depends on the underlying structure of the
-   * tree. Refer to the documentation of the structure itself for more details.
-   *
-   * @example Finding values in the tree
-   * ```ts
-   * import { BinarySearchTree } from "@std/data-structures";
-   * import { assertEquals } from "@std/assert";
-   *
-   * const tree = BinarySearchTree.from<number>([42]);
-   *
-   * assertEquals(tree.ceiling(41), 42);
-   * assertEquals(tree.ceiling(42), 42);
-   * assertEquals(tree.ceiling(43), null);
-   * ```
-   *
-   * @param value The value to search for in the binary search tree.
-   * @returns The ceiling if it was found, or null if not.
-   */
-  ceiling(value: T): T | null {
-    return this.#findNode(value, "higher")?.value ?? null;
-  }
-
-  /**
-   * Finds the highest (rightmost) value in the binary search tree which is
-   * less than or equal to the given value, or null if the given value
-   * is lower than all elements of the tree.
-   *
-   * The complexity of this operation depends on the underlying structure of the
-   * tree. Refer to the documentation of the structure itself for more details.
-   *
-   * @example Finding values in the tree
-   * ```ts
-   * import { BinarySearchTree } from "@std/data-structures";
-   * import { assertEquals } from "@std/assert";
-   *
-   * const tree = BinarySearchTree.from<number>([42]);
-   *
-   * assertEquals(tree.floor(41), null);
-   * assertEquals(tree.floor(42), 42);
-   * assertEquals(tree.floor(43), 42);
-   * ```
-   *
-   * @param value The value to search for in the binary search tree.
-   * @returns The floor if it was found, or null if not.
-   */
-  floor(value: T): T | null {
-    return this.#findNode(value, "lower")?.value ?? null;
-  }
-
-  /**
-   * Finds the lowest (leftmost) value in the binary search tree which is
-   * strictly greater than the given value, or null if the given value
-   * is higher than or equal to all elements of the tree
-   *
-   * The complexity of this operation depends on the underlying structure of the
-   * tree. Refer to the documentation of the structure itself for more details.
-   *
-   * @example Finding values in the tree
-   * ```ts
-   * import { BinarySearchTree } from "@std/data-structures";
-   * import { assertEquals } from "@std/assert";
-   *
-   * const tree = BinarySearchTree.from<number>([42]);
-   *
-   * assertEquals(tree.higher(41), 42);
-   * assertEquals(tree.higher(42), null);
-   * assertEquals(tree.higher(43), null);
-   * ```
-   *
-   * @param value The value to search for in the binary search tree.
-   * @returns The higher value if it was found, or null if not.
-   */
-  higher(value: T): T | null {
-    return this.#findNode(value, "higher", false)?.value ?? null;
-  }
-
-  /**
-   * Finds the highest (rightmost) value in the binary search tree which is
-   * strictly less than the given value, or null if the given value
-   * is lower than or equal to all elements of the tree
-   *
-   * The complexity of this operation depends on the underlying structure of the
-   * tree. Refer to the documentation of the structure itself for more details.
-   *
-   * @example Finding values in the tree
-   * ```ts
-   * import { BinarySearchTree } from "@std/data-structures";
-   * import { assertEquals } from "@std/assert";
-   *
-   * const tree = BinarySearchTree.from<number>([42]);
-   *
-   * assertEquals(tree.lower(41), null);
-   * assertEquals(tree.lower(42), null);
-   * assertEquals(tree.lower(43), 42);
-   * ```
-   *
-   * @param value The value to search for in the binary search tree.
-   * @returns The lower value if it was found, or null if not.
-   */
-  lower(value: T): T | null {
-    return this.#findNode(value, "lower", false)?.value ?? null;
-  }
-
   /**
    * Retrieve the lowest (left most) value in the binary search tree, or null if
    * the tree is empty.

data_structures/binary_search_tree_test.ts

@@ -556,47 +556,3 @@ Deno.test("BinarySearchTree.clear()", () => {
   tree.clear();
   assert(tree.isEmpty());
 });
-
-Deno.test("BinarySearchTree.ceiling()", () => {
-  const tree = BinarySearchTree.from([4, 2, 1, 3, 6, 5, 7]);
-  assertEquals(tree.ceiling(0.5), 1);
-  assertEquals(tree.ceiling(1), 1);
-  assertEquals(tree.ceiling(1.5), 2);
-  assertEquals(tree.ceiling(3.5), 4);
-  assertEquals(tree.ceiling(6.5), 7);
-  assertEquals(tree.ceiling(7), 7);
-  assertEquals(tree.ceiling(7.5), null);
-});
-
-Deno.test("BinarySearchTree.floor()", () => {
-  const tree = BinarySearchTree.from([4, 2, 1, 3, 6, 5, 7]);
-  assertEquals(tree.floor(0.5), null);
-  assertEquals(tree.floor(1), 1);
-  assertEquals(tree.floor(1.5), 1);
-  assertEquals(tree.floor(4.5), 4);
-  assertEquals(tree.floor(6.5), 6);
-  assertEquals(tree.floor(7), 7);
-  assertEquals(tree.floor(7.5), 7);
-});
-
-Deno.test("BinarySearchTree.higher()", () => {
-  const tree = BinarySearchTree.from([4, 2, 1, 3, 6, 5, 7]);
-  assertEquals(tree.higher(0.5), 1);
-  assertEquals(tree.higher(1), 2);
-  assertEquals(tree.higher(1.5), 2);
-  assertEquals(tree.higher(3.5), 4);
-  assertEquals(tree.higher(6.5), 7);
-  assertEquals(tree.higher(7), null);
-  assertEquals(tree.higher(7.5), null);
-});
-
-Deno.test("BinarySearchTree.lower()", () => {
-  const tree = BinarySearchTree.from([4, 2, 1, 3, 6, 5, 7]);
-  assertEquals(tree.lower(0.5), null);
-  assertEquals(tree.lower(1), null);
-  assertEquals(tree.lower(1.5), 1);
-  assertEquals(tree.lower(4.5), 4);
-  assertEquals(tree.lower(6.5), 6);
-  assertEquals(tree.lower(7), 6);
-  assertEquals(tree.lower(7.5), 7);
-});

data_structures/deno.json

@@ -6,6 +6,7 @@
     "./unstable-bidirectional-map": "./unstable_bidirectional_map.ts",
     "./binary-heap": "./binary_heap.ts",
     "./binary-search-tree": "./binary_search_tree.ts",
+    "./unstable-binary-search-tree": "./unstable_binary_search_tree.ts",
     "./comparators": "./comparators.ts",
     "./red-black-tree": "./red_black_tree.ts"
   }