binary-tree-typed 1.53.7 → 1.54.0

package/src/data-structures/binary-tree/binary-tree.ts

@@ -23,6 +23,7 @@ import {
   NodeDisplayLayout,
   NodePredicate,
   OptNodeOrNull,
+  type RBTNColor,
   ToEntryFn
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -52,7 +53,7 @@ export class BinaryTreeNode<
     this.value = value;
   }
 
-  protected _left?: OptNodeOrNull<NODE>;
+  _left?: OptNodeOrNull<NODE>;
 
   get left(): OptNodeOrNull<NODE> {
     return this._left;
@@ -65,7 +66,7 @@ export class BinaryTreeNode<
     this._left = v;
   }
 
-  protected _right?: OptNodeOrNull<NODE>;
+  _right?: OptNodeOrNull<NODE>;
 
   get right(): OptNodeOrNull<NODE> {
     return this._right;
@@ -78,6 +79,36 @@ export class BinaryTreeNode<
     this._right = v;
   }
 
+  _height: number = 0;
+
+  get height(): number {
+    return this._height;
+  }
+
+  set height(value: number) {
+    this._height = value;
+  }
+
+  _color: RBTNColor = 'BLACK';
+
+  get color(): RBTNColor {
+    return this._color;
+  }
+
+  set color(value: RBTNColor) {
+    this._color = value;
+  }
+
+  _count: number = 1;
+
+  get count(): number {
+    return this._count;
+  }
+
+  set count(value: number) {
+    this._count = value;
+  }
+
   get familyPosition(): FamilyPosition {
     const that = this as unknown as NODE;
     if (!this.parent) {
@@ -105,11 +136,23 @@ export class BinaryTree<
     K = any,
     V = any,
     R = object,
+    MK = any,
+    MV = any,
+    MR = object,
     NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
-    TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>
+    TREE extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE> = BinaryTree<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      BinaryTreeNested<K, V, R, MK, MV, MR, NODE>
+    >
   >
   extends IterableEntryBase<K, V | undefined>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
 {
   iterationType: IterationType = 'ITERATIVE';
 
@@ -172,6 +215,9 @@ export class BinaryTree<
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function creates a new binary tree node with a specified key and optional value.
    * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
    * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
@@ -193,7 +239,7 @@ export class BinaryTree<
    * @returns A new instance of a binary tree with the specified options is being returned.
    */
   createTree(options?: BinaryTreeOptions<K, V, R>): TREE {
-    return new BinaryTree<K, V, R, NODE, TREE>([], {
+    return new BinaryTree<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       toEntryFn: this._toEntryFn,
@@ -216,7 +262,7 @@ export class BinaryTree<
    * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
    * value.
    */
-  keyValueNodeEntryRawToNodeAndValue(
+  protected _keyValueNodeEntryRawToNodeAndValue(
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V
   ): [OptNodeOrNull<NODE>, V | undefined] {
@@ -420,7 +466,7 @@ export class BinaryTree<
    * key was found and the node was replaced instead of inserted.
    */
   add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (newNode === undefined) return false;
 
     // If the tree is empty, directly set the new node as the root node
@@ -1673,7 +1719,7 @@ export class BinaryTree<
     const newTree = this.createTree();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, value, key, index++, this)) {
+      if (predicate.call(thisArg, key, value, index++, this)) {
         newTree.add([key, value]);
       }
     }
@@ -1684,36 +1730,34 @@ export class BinaryTree<
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-   * function to each value, and returns a new tree with the updated values.
-   * @param callback - The `callback` parameter in the `map` method is a function that will be called
-   * on each entry in the tree. It takes four arguments:
-   * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-   * that specifies the value to be passed as `this` when executing the callback function. If provided,
-   * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-   * @returns The `map` method is returning a new tree with the entries modified by the provided
-   * callback function. Each entry in the original tree is passed to the callback function, and the
-   * result of the callback function is added to the new tree.
+   * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+   * entry in the original BinaryTree.
+   * @param callback - A function that will be called for each entry in the current binary tree. It
+   * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+   * arguments.
+   * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+   * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+   * tree being created during the mapping process. These options could include things like custom
+   * comparators, initial
+   * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+   * of `this` when executing the `callback` function. It allows you to set the context (value of
+   * `this`) within the callback function. If `thisArg` is provided, it will be passed
+   * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+   * the result of applying the provided `callback` function to each entry in the original tree.
    */
-  map(callback: EntryCallback<K, V | undefined, V>, thisArg?: any) {
-    const newTree = this.createTree();
+  map(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: BinaryTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ): BinaryTree<MK, MV, MR> {
+    const newTree = new BinaryTree<MK, MV, MR>([], options);
     let index = 0;
     for (const [key, value] of this) {
-      newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
+      newTree.add(callback.call(thisArg, key, value, index++, this));
     }
     return newTree;
   }
 
-  // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-  // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
-  // //   const newTree = this.createTree();
-  // //   for (const [key, value] of this) {
-  // //     newTree.add(key, callback([key, value], this));
-  // //   }
-  // //   return newTree;
-  // // }
-  //
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1743,7 +1787,7 @@ export class BinaryTree<
     if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)\n`;
 
     const display = (root: OptNodeOrNull<NODE>): void => {
-      const [lines, , ,] = this._displayAux(root, opts);
+      const [lines, ,] = this._displayAux(root, opts);
       let paragraph = '';
       for (const line of lines) {
         paragraph += line + '\n';

package/src/data-structures/binary-tree/bst.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {
+import {
   BSTNested,
   BSTNodeNested,
   BSTNOptKeyOrNode,
@@ -15,10 +15,12 @@ import type {
   Comparator,
   CP,
   DFSOrderPattern,
+  EntryCallback,
   IterationType,
   NodeCallback,
   NodePredicate,
-  OptNode
+  OptNode,
+  OptNodeOrNull
 } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
@@ -40,13 +42,13 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
     this._right = undefined;
   }
 
-  protected override _left?: NODE;
+  override _left?: OptNodeOrNull<NODE>;
 
   /**
    * The function returns the value of the `_left` property.
    * @returns The `_left` property of the current object is being returned.
    */
-  override get left(): OptNode<NODE> {
+  override get left(): OptNodeOrNull<NODE> {
     return this._left;
   }
 
@@ -55,21 +57,21 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
    * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be an
    * instance of the `NODE` class or `undefined`.
    */
-  override set left(v: OptNode<NODE>) {
+  override set left(v: OptNodeOrNull<NODE>) {
     if (v) {
       v.parent = this as unknown as NODE;
     }
     this._left = v;
   }
 
-  protected override _right?: NODE;
+  override _right?: OptNodeOrNull<NODE>;
 
   /**
    * The function returns the right node of a binary tree or undefined if there is no right node.
    * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
    * `undefined`.
    */
-  override get right(): OptNode<NODE> {
+  override get right(): OptNodeOrNull<NODE> {
     return this._right;
   }
 
@@ -78,7 +80,7 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
    * @param {OptNode<NODE>} v - The parameter `v` is of type `OptNode<NODE>`. It can either be a
    * `NODE` object or `undefined`.
    */
-  override set right(v: OptNode<NODE>) {
+  override set right(v: OptNodeOrNull<NODE>) {
     if (v) {
       v.parent = this as unknown as NODE;
     }
@@ -95,32 +97,48 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  * @example
- * // Find kth smallest element
- *     // Create a BST with some elements
- *     const bst = new BST<number>([5, 3, 7, 1, 4, 6, 8]);
- *     const sortedKeys = bst.dfs(node => node.key, 'IN');
+ * // Merge 3 sorted datasets
+ *     const dataset1 = new BST<number, string>([
+ *       [1, 'A'],
+ *       [7, 'G']
+ *     ]);
+ *     const dataset2 = [
+ *       [2, 'B'],
+ *       [6, 'F']
+ *     ];
+ *     const dataset3 = new BST<number, string>([
+ *       [3, 'C'],
+ *       [5, 'E'],
+ *       [4, 'D']
+ *     ]);
  *
- *     // Helper function to find kth smallest
- *     const findKthSmallest = (k: number): number | undefined => {
- *       return sortedKeys[k - 1];
- *     };
+ *     // Merge datasets into a single BinarySearchTree
+ *     const merged = new BST<number, string>(dataset1);
+ *     merged.addMany(dataset2);
+ *     merged.merge(dataset3);
  *
- *     // Assertions
- *     console.log(findKthSmallest(1)); // 1
- *     console.log(findKthSmallest(3)); // 4
- *     console.log(findKthSmallest(7)); // 8
+ *     // Verify merged dataset is in sorted order
+ *     console.log([...merged.values()]); // ['A', 'B', 'C', 'D', 'E', 'F', 'G']
  * @example
  * // Find elements in a range
  *     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
  *     console.log(bst.search(new Range(5, 10))); // [10, 5, 7]
- *     console.log(bst.search(new Range(4, 12))); // [10, 12, 5, 7]
+ *     console.log(bst.rangeSearch([4, 12], node => node.key.toString())); // ['10', '12', '5', '7']
  *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
- *     console.log(bst.search(new Range(15, 20))); // [15, 18]
+ *     console.log(bst.rangeSearch([15, 20])); // [15, 18]
  *     console.log(bst.search(new Range(15, 20, false))); // [18]
  * @example
  * // Find lowest common ancestor
  *     const bst = new BST<number>([20, 10, 30, 5, 15, 25, 35, 3, 7, 12, 18]);
  *
+ *     // LCA helper function
+ *     const findLCA = (num1: number, num2: number): number | undefined => {
+ *       const path1 = bst.getPathToRoot(num1);
+ *       const path2 = bst.getPathToRoot(num2);
+ *       // Find the first common ancestor
+ *       return findFirstCommon(path1, path2);
+ *     };
+ *
  *     function findFirstCommon(arr1: number[], arr2: number[]): number | undefined {
  *       for (const num of arr1) {
  *         if (arr2.indexOf(num) !== -1) {
@@ -130,14 +148,6 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  *       return undefined;
  *     }
  *
- *     // LCA helper function
- *     const findLCA = (num1: number, num2: number): number | undefined => {
- *       const path1 = bst.getPathToRoot(num1);
- *       const path2 = bst.getPathToRoot(num2);
- *       // Find the first common ancestor
- *       return findFirstCommon(path1, path2);
- *     };
- *
  *     // Assertions
  *     console.log(findLCA(3, 10)); // 7
  *     console.log(findLCA(5, 35)); // 15
@@ -147,11 +157,23 @@ export class BST<
     K = any,
     V = any,
     R = object,
+    MK = any,
+    MV = any,
+    MR = object,
     NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>,
-    TREE extends BST<K, V, R, NODE, TREE> = BST<K, V, R, NODE, BSTNested<K, V, R, NODE>>
+    TREE extends BST<K, V, R, MK, MV, MR, NODE, TREE> = BST<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      BSTNested<K, V, R, MK, MV, MR, NODE>
+    >
   >
-  extends BinaryTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  extends BinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
+  implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
 {
   /**
    * This is the constructor function for a Binary Search Tree class in TypeScript.
@@ -165,8 +187,8 @@ export class BST<
     super([], options);
 
     if (options) {
-      const { extractComparable, isReverse } = options;
-      if (typeof extractComparable === 'function') this._extractComparable = extractComparable;
+      const { specifyComparable, isReverse } = options;
+      if (typeof specifyComparable === 'function') this._specifyComparable = specifyComparable;
       if (isReverse !== undefined) this._isReverse = isReverse;
     }
 
@@ -214,10 +236,10 @@ export class BST<
    * @returns a new instance of the BST class with the provided options.
    */
   override createTree(options?: BSTOptions<K, V, R>): TREE {
-    return new BST<K, V, R, NODE, TREE>([], {
+    return new BST<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
@@ -233,11 +255,11 @@ export class BST<
    * value associated with a key in a key-value pair.
    * @returns either a NODE object or undefined.
    */
-  override keyValueNodeEntryRawToNodeAndValue(
+  protected override _keyValueNodeEntryRawToNodeAndValue(
     keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
     value?: V
   ): [OptNode<NODE>, V | undefined] {
-    const [node, entryValue] = super.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (node === null) return [undefined, undefined];
     return [node, value ?? entryValue];
   }
@@ -284,7 +306,7 @@ export class BST<
    * this._DEFAULT_COMPARATOR`.
    */
   override isKey(key: any): key is K {
-    return isComparable(key, this._extractComparable !== undefined);
+    return isComparable(key, this._specifyComparable !== undefined);
   }
 
   /**
@@ -299,7 +321,7 @@ export class BST<
    * @returns a boolean value.
    */
   override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (newNode === undefined) return false;
 
     if (this._root === undefined) {
@@ -322,7 +344,7 @@ export class BST<
           this._size++;
           return true;
         }
-        current = current.left;
+        if (current.left !== null) current = current.left;
       } else {
         if (current.right === undefined) {
           current.right = newNode;
@@ -330,7 +352,7 @@ export class BST<
           this._size++;
           return true;
         }
-        current = current.right;
+        if (current.right !== null) current = current.right;
       }
     }
 
@@ -455,19 +477,6 @@ export class BST<
     return inserted;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `merge` function overrides the base class method by adding elements from another
-   * binary search tree.
-   * @param anotherTree - `anotherTree` is an instance of a Binary Search Tree (BST) with key type `K`,
-   * value type `V`, return type `R`, node type `NODE`, and tree type `TREE`.
-   */
-  override merge(anotherTree: BST<K, V, R, NODE, TREE>) {
-    this.addMany(anotherTree, [], false);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(k + log n)
@@ -609,6 +618,37 @@ export class BST<
     return ans;
   }
 
+  /**
+   * Time Complexity: O(log n)
+   * Space Complexity: O(n)
+   *
+   * The `rangeSearch` function searches for nodes within a specified range in a binary search tree.
+   * @param {Range<K> | [K, K]} range - The `range` parameter in the `rangeSearch` function can be
+   * either a `Range` object or an array of two elements representing the range boundaries.
+   * @param {C} callback - The `callback` parameter in the `rangeSearch` function is a callback
+   * function that is used to process each node that is found within the specified range during the
+   * search operation. It is of type `NodeCallback<NODE>`, where `NODE` is the type of nodes in the
+   * data structure.
+   * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `rangeSearch`
+   * function represents the node from which the search for nodes within the specified range will
+   * begin. It is the starting point for the range search operation.
+   * @param {IterationType} iterationType - The `iterationType` parameter in the `rangeSearch` function
+   * is used to specify the type of iteration to be performed during the search operation. It has a
+   * default value of `this.iterationType`, which suggests that it is likely a property of the class or
+   * object that the `rangeSearch`
+   * @returns The `rangeSearch` function is returning the result of calling the `search` method with
+   * the specified parameters.
+   */
+  rangeSearch<C extends NodeCallback<NODE>>(
+    range: Range<K> | [K, K],
+    callback: C = this._DEFAULT_NODE_CALLBACK as C,
+    startNode: BTNRep<K, V, NODE> | R = this._root,
+    iterationType: IterationType = this.iterationType
+  ) {
+    const searchRange: Range<K> = range instanceof Range ? range : new Range(range[0], range[1]);
+    return this.search(searchRange, false, callback, startNode, iterationType);
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -847,7 +887,7 @@ export class BST<
     let balanced = true;
 
     if (iterationType === 'RECURSIVE') {
-      const _height = (cur: OptNode<NODE>): number => {
+      const _height = (cur: OptNodeOrNull<NODE>): number => {
         if (!cur) return 0;
         const leftHeight = _height(cur.left),
           rightHeight = _height(cur.right);
@@ -864,7 +904,7 @@ export class BST<
       while (stack.length > 0 || node) {
         if (node) {
           stack.push(node);
-          node = node.left;
+          if (node.left !== null) node = node.left;
         } else {
           node = stack[stack.length - 1];
           if (!node.right || last === node.right) {
@@ -891,14 +931,14 @@ export class BST<
       if (a < b) return -1;
       return 0;
     }
-    if (this._extractComparable) {
-      if (this._extractComparable(a) > this._extractComparable(b)) return 1;
-      if (this._extractComparable(a) < this._extractComparable(b)) return -1;
+    if (this._specifyComparable) {
+      if (this._specifyComparable(a) > this._specifyComparable(b)) return 1;
+      if (this._specifyComparable(a) < this._specifyComparable(b)) return -1;
       return 0;
     }
     if (typeof a === 'object' || typeof b === 'object') {
       throw TypeError(
-        `When comparing object types, a custom extractComparable must be defined in the constructor's options parameter.`
+        `When comparing object types, a custom specifyComparable must be defined in the constructor's options parameter.`
       );
     }
 
@@ -913,15 +953,15 @@ export class BST<
     return this._comparator;
   }
 
-  protected _extractComparable?: (key: K) => Comparable;
+  protected _specifyComparable?: (key: K) => Comparable;
 
   /**
-   * This function returns the value of the `_extractComparable` property.
-   * @returns The method `extractComparable()` is being returned, which is a getter method for the
-   * `_extractComparable` property.
+   * This function returns the value of the `_specifyComparable` property.
+   * @returns The method `specifyComparable()` is being returned, which is a getter method for the
+   * `_specifyComparable` property.
    */
-  get extractComparable() {
-    return this._extractComparable;
+  get specifyComparable() {
+    return this._specifyComparable;
   }
 
   /**
@@ -939,4 +979,17 @@ export class BST<
   protected _compare(a: K, b: K) {
     return this._isReverse ? -this._comparator(a, b) : this._comparator(a, b);
   }
+
+  override map(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: BSTOptions<MK, MV, MR>,
+    thisArg?: any
+  ): BST<MK, MV, MR> {
+    const newTree = new BST<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
+    }
+    return newTree;
+  }
 }

package/src/data-structures/binary-tree/index.ts

@@ -3,6 +3,6 @@ export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './rb-tree';
+export * from './red-black-tree';
 export * from './avl-tree-multi-map';
 export * from './tree-multi-map';