graph-typed 1.53.9 → 1.54.0

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

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 import {
+  BSTNested,
   BSTNodeNested,
   BSTNOptKeyOrNode,
   BSTOptions,
@@ -18,7 +19,8 @@ import {
   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;
     }
@@ -151,9 +153,27 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  *     console.log(findLCA(5, 35)); // 15
  *     console.log(findLCA(20, 30)); // 25
  */
-export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>>
-  extends BinaryTree<K, V, R, NODE>
-  implements IBinaryTree<K, V, R, NODE>
+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, 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, 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.
@@ -196,45 +216,6 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
     return this._isReverse;
   }
 
-  protected _comparator: Comparator<K> = (a: K, b: K): number => {
-    if (isComparable(a) && isComparable(b)) {
-      if (a > b) return 1;
-      if (a < b) return -1;
-      return 0;
-    }
-    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 specifyComparable must be defined in the constructor's options parameter.`
-      );
-    }
-
-    return 0;
-  };
-
-  /**
-   * The function returns the value of the _comparator property.
-   * @returns The `_comparator` property is being returned.
-   */
-  get comparator() {
-    return this._comparator;
-  }
-
-  protected _specifyComparable?: (key: K) => Comparable;
-
-  /**
-   * 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 specifyComparable() {
-    return this._specifyComparable;
-  }
-
   /**
    * The function creates a new BSTNode with the given key and value and returns it.
    * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
@@ -248,26 +229,39 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `createTree` function in TypeScript overrides the default options with the provided options to
-   * create a new Binary Search Tree.
-   * @param [options] - The `options` parameter in the `createTree` method is an optional object that
-   * can contain the following properties:
-   * @returns A new instance of a Binary Search Tree (BST) is being returned with the specified options
-   * and properties inherited from the current instance.
+   * The function creates a new binary search tree with the specified options.
+   * @param [options] - The `options` parameter is an optional object that allows you to customize the
+   * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which has the
+   * following properties:
+   * @returns a new instance of the BST class with the provided options.
    */
-  // @ts-ignore
-  override createTree(options?: BSTOptions<K, V, R>) {
-    return new BST<K, V, R>([], {
+  override createTree(options?: BSTOptions<K, V, R>): TREE {
+    return new BST<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
-    });
+    }) as TREE;
+  }
+
+  /**
+   * The function overrides a method and converts a key, value pair or entry or raw element to a node.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
+   * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
+   * element.
+   * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
+   * value associated with a key in a key-value pair.
+   * @returns either a NODE object or undefined.
+   */
+  protected override _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V
+  ): [OptNode<NODE>, V | undefined] {
+    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    if (node === null) return [undefined, undefined];
+    return [node, value ?? entryValue];
   }
 
   /**
@@ -350,7 +344,7 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
           this._size++;
           return true;
         }
-        current = current.left;
+        if (current.left !== null) current = current.left;
       } else {
         if (current.right === undefined) {
           current.right = newNode;
@@ -358,7 +352,7 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
           this._size++;
           return true;
         }
-        current = current.right;
+        if (current.right !== null) current = current.right;
       }
     }
 
@@ -483,19 +477,6 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
     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: this) {
-    this.addMany(anotherTree, [], false);
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(k + log n)
@@ -906,7 +887,7 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
     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);
@@ -923,7 +904,7 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
       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) {
@@ -944,36 +925,43 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
     return balanced;
   }
 
-  // @ts-ignore
-  override map<MK, MV, MR>(
-    callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: BSTOptions<MK, MV, MR>,
-    thisArg?: any
-  ) {
-    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));
+  protected _comparator: Comparator<K> = (a: K, b: K): number => {
+    if (isComparable(a) && isComparable(b)) {
+      if (a > b) return 1;
+      if (a < b) return -1;
+      return 0;
     }
-    return newTree;
+    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 specifyComparable must be defined in the constructor's options parameter.`
+      );
+    }
+
+    return 0;
+  };
+
+  /**
+   * The function returns the value of the _comparator property.
+   * @returns The `_comparator` property is being returned.
+   */
+  get comparator() {
+    return this._comparator;
   }
 
+  protected _specifyComparable?: (key: K) => Comparable;
+
   /**
-   * The function overrides a method and converts a key, value pair or entry or raw element to a node.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - A variable that can be of
-   * type R or BTNRep<K, V, NODE>. It represents either a key, a node, an entry, or a raw
-   * element.
-   * @param {V} [value] - The `value` parameter is an optional value of type `V`. It represents the
-   * value associated with a key in a key-value pair.
-   * @returns either a NODE object or undefined.
+   * 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.
    */
-  protected override _keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V
-  ): [OptNode<NODE>, V | undefined] {
-    const [node, entryValue] = super._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
-    if (node === null) return [undefined, undefined];
-    return [node, value ?? entryValue];
+  get specifyComparable() {
+    return this._specifyComparable;
   }
 
   /**
@@ -991,4 +979,17 @@ export class BST<K = any, V = any, R = object, NODE extends BSTNode<K, V, NODE>
   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/red-black-tree.ts

@@ -6,6 +6,7 @@ import type {
   OptNode,
   RBTNColor,
   RedBlackTreeOptions,
+  RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
 import { BST, BSTNode } from './bst';
@@ -31,24 +32,6 @@ export class RedBlackTreeNode<
     super(key, value);
     this._color = color;
   }
-
-  protected _color: RBTNColor;
-
-  /**
-   * The function returns the color value of a variable.
-   * @returns The color value stored in the private variable `_color`.
-   */
-  get color(): RBTNColor {
-    return this._color;
-  }
-
-  /**
-   * The function sets the color property to the specified value.
-   * @param {RBTNColor} value - The value parameter is of type RBTNColor.
-   */
-  set color(value: RBTNColor) {
-    this._color = value;
-  }
 }
 
 /**
@@ -108,16 +91,29 @@ export class RedBlackTree<
     K = any,
     V = any,
     R = object,
-    NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>
+    MK = any,
+    MV = any,
+    MR = object,
+    NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>,
+    TREE extends RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE> = RedBlackTree<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      RedBlackTreeNested<K, V, R, MK, MV, MR, NODE>
+    >
   >
-  extends BST<K, V, R, NODE>
-  implements IBinaryTree<K, V, R, NODE>
+  extends BST<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 Red-Black Tree data structure in TypeScript.
    * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
    * iterable object that can contain either keys, nodes, entries, or raw elements. It is used to
-   * initialize the RedBlackTree with the provided elements.
+   * initialize the RBTree with the provided elements.
    * @param [options] - The `options` parameter is an optional object that can be passed to the
    * constructor. It is of type `RedBlackTreeOptions<K, V, R>`. This object can contain various options for
    * configuring the behavior of the Red-Black Tree. The specific properties and their meanings would
@@ -162,23 +158,19 @@ export class RedBlackTree<
   }
 
   /**
-   * The function `createTree` overrides the default implementation to create a Red-Black Tree with
-   * specified options in TypeScript.
-   * @param [options] - The `options` parameter in the `createTree` method is of type `RedBlackTreeOptions<K,
-   * V, R>`, which is a generic type with three type parameters `K`, `V`, and `R`. This parameter
-   * allows you to pass additional configuration options when creating a new Red-
-   * @returns A new instance of a RedBlackTree with the specified options and properties from the
-   * current object is being returned.
+   * The function creates a new Red-Black Tree with the specified options.
+   * @param [options] - The `options` parameter is an optional object that contains additional
+   * configuration options for creating the Red-Black Tree. It has the following properties:
+   * @returns a new instance of a RedBlackTree object.
    */
-  // @ts-ignore
-  override createTree(options?: RedBlackTreeOptions<K, V, R>) {
-    return new RedBlackTree<K, V, R>([], {
+  override createTree(options?: RedBlackTreeOptions<K, V, R>): TREE {
+    return new RedBlackTree<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       ...options
-    });
+    }) as TREE;
   }
 
   /**
@@ -276,8 +268,10 @@ export class RedBlackTree<
     let replacementNode: NODE | undefined;
 
     if (!this.isRealNode(nodeToDelete.left)) {
-      replacementNode = nodeToDelete.right;
-      this._transplant(nodeToDelete, nodeToDelete.right);
+      if (nodeToDelete.right !== null) {
+        replacementNode = nodeToDelete.right;
+        this._transplant(nodeToDelete, nodeToDelete.right);
+      }
     } else if (!this.isRealNode(nodeToDelete.right)) {
       replacementNode = nodeToDelete.left;
       this._transplant(nodeToDelete, nodeToDelete.left);
@@ -285,15 +279,17 @@ export class RedBlackTree<
       const successor = this.getLeftMost(node => node, nodeToDelete.right);
       if (successor) {
         originalColor = successor.color;
-        replacementNode = successor.right;
+        if (successor.right !== null) replacementNode = successor.right;
 
         if (successor.parent === nodeToDelete) {
           if (this.isRealNode(replacementNode)) {
             replacementNode.parent = successor;
           }
         } else {
-          this._transplant(successor, successor.right);
-          successor.right = nodeToDelete.right;
+          if (successor.right !== null) {
+            this._transplant(successor, successor.right);
+            successor.right = nodeToDelete.right;
+          }
           if (this.isRealNode(successor.right)) {
             successor.right.parent = successor;
           }
@@ -320,40 +316,6 @@ export class RedBlackTree<
     return results;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
-   * applying a callback to each entry in the original tree.
-   * @param callback - A function that will be called for each entry in the tree, with parameters
-   * representing the key, value, index, and the tree itself. It should return an entry for the new
-   * tree.
-   * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
-   * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
-   * Tree that will be created during the mapping process. These options could include things like
-   * custom comparators
-   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
-   * the value of `this` when executing the `callback` function. It allows you to set the context
-   * (value of `this`) for the callback function. This can be useful when you want to access properties
-   * or
-   * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
-   * provided callback function.
-   */
-  // @ts-ignore
-  override map<MK, MV, MR>(
-    callback: EntryCallback<K, V | undefined, [MK, MV]>,
-    options?: RedBlackTreeOptions<MK, MV, MR>,
-    thisArg?: any
-  ) {
-    const newTree = new RedBlackTree<MK, MV, MR>([], options);
-    let index = 0;
-    for (const [key, value] of this) {
-      newTree.add(callback.call(thisArg, key, value, index++, this));
-    }
-    return newTree;
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -498,7 +460,7 @@ export class RedBlackTree<
       } else {
         // Symmetric case for the right child (left and right exchanged)
         // Follow the same logic as above with left and right exchanged
-        const y: NODE | undefined = z?.parent?.parent?.left;
+        const y: NODE | undefined = z?.parent?.parent?.left ?? undefined;
         if (y?.color === 'RED') {
           z.parent.color = 'BLACK';
           y.color = 'BLACK';
@@ -675,4 +637,37 @@ export class RedBlackTree<
     x.right = y;
     y.parent = x;
   }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function in TypeScript overrides the default behavior to create a new Red-Black Tree by
+   * applying a callback to each entry in the original tree.
+   * @param callback - A function that will be called for each entry in the tree, with parameters
+   * representing the key, value, index, and the tree itself. It should return an entry for the new
+   * tree.
+   * @param [options] - The `options` parameter in the `map` method is of type `RedBlackTreeOptions<MK, MV,
+   * MR>`. This parameter allows you to specify additional options or configurations for the Red-Black
+   * Tree that will be created during the mapping process. These options could include things like
+   * custom comparators
+   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+   * the value of `this` when executing the `callback` function. It allows you to set the context
+   * (value of `this`) for the callback function. This can be useful when you want to access properties
+   * or
+   * @returns A new Red-Black Tree is being returned, where each entry has been transformed using the
+   * provided callback function.
+   */
+  override map(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: RedBlackTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ): RedBlackTree<MK, MV, MR> {
+    const newTree = new RedBlackTree<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
+    }
+    return newTree;
+  }
 }