data-structure-typed 1.53.9 → 1.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.53.9",
+  "version": "1.54.0",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -70,11 +70,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^1.53.8",
+    "avl-tree-typed": "^1.53.9",
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.53.8",
-    "bst-typed": "^1.53.8",
-    "data-structure-typed": "^1.53.8",
+    "bst-typed": "^1.53.9",
+    "data-structure-typed": "^1.53.9",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -83,7 +83,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^1.53.8",
+    "heap-typed": "^1.53.9",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 import type {
+  AVLTreeMultiMapNested,
   AVLTreeMultiMapNodeNested,
   AVLTreeMultiMapOptions,
   BinaryTreeDeleteResult,
@@ -36,25 +37,6 @@ export class AVLTreeMultiMapNode<
     super(key, value);
     this.count = count;
   }
-
-  protected _count: number = 1;
-
-  /**
-   * The function returns the value of the protected variable _count.
-   * @returns The count property of the object, which is of type number.
-   */
-  get count(): number {
-    return this._count;
-  }
-
-  /**
-   * The above function sets the value of the count property.
-   * @param {number} value - The value parameter is of type number, which means it can accept any
-   * numeric value.
-   */
-  set count(value: number) {
-    this._count = value;
-  }
 }
 
 /**
@@ -64,10 +46,23 @@ export class AVLTreeMultiMap<
     K = any,
     V = any,
     R = object,
-    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>
+    MK = any,
+    MV = any,
+    MR = object,
+    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
+    TREE extends AVLTreeMultiMap<K, V, R, MK, MV, MR, NODE, TREE> = AVLTreeMultiMap<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      AVLTreeMultiMapNested<K, V, R, MK, MV, MR, NODE>
+    >
   >
-  extends AVLTree<K, V, R, NODE>
-  implements IBinaryTree<K, V, R, NODE>
+  extends AVLTree<K, V, R, MK, MV, MR, NODE, TREE>
+  implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
 {
   /**
    * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
@@ -132,16 +127,15 @@ export class AVLTreeMultiMap<
    * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
    * object.
    */
-  // @ts-ignore
-  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>) {
-    return new AVLTreeMultiMap<K, V, R, NODE>([], {
+  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE {
+    return new AVLTreeMultiMap<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;
   }
 
   /**
@@ -220,7 +214,7 @@ export class AVLTreeMultiMap<
     } else {
       if (!curr.left) {
         if (!parent) {
-          if (curr.right !== undefined) this._setRoot(curr.right);
+          if (curr.right !== undefined && curr.right !== null) this._setRoot(curr.right);
         } else {
           const { familyPosition: fp } = curr;
           if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
@@ -330,8 +324,7 @@ export class AVLTreeMultiMap<
    * The function overrides the clone method to create a deep copy of a tree object.
    * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
    */
-  // @ts-ignore
-  override clone() {
+  override clone(): TREE {
     const cloned = this.createTree();
     if (this._isMapMode) this.bfs(node => cloned.add(node.key, undefined, node.count));
     else this.bfs(node => cloned.add(node.key, node.value, node.count));
@@ -357,12 +350,11 @@ export class AVLTreeMultiMap<
    * `callback` function along with the index and the original tree itself. The transformed entries are
    * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
    */
-  // @ts-ignore
   override map<MK, MV, MR>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: AVLTreeMultiMapOptions<MK, MV, MR>,
     thisArg?: any
-  ) {
+  ): AVLTreeMultiMap<MK, MV, MR> {
     const newTree = new AVLTreeMultiMap<MK, MV, MR>([], options);
     let index = 0;
     for (const [key, value] of this) {

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

@@ -7,6 +7,7 @@
  */
 import { BST, BSTNode } from './bst';
 import type {
+  AVLTreeNested,
   AVLTreeNodeNested,
   AVLTreeOptions,
   BinaryTreeDeleteResult,
@@ -31,26 +32,6 @@ export class AVLTreeNode<
    */
   constructor(key: K, value?: V) {
     super(key, value);
-    this._height = 0;
-  }
-
-  protected _height: number;
-
-  /**
-   * The function returns the value of the height property.
-   * @returns The height of the object.
-   */
-  get height(): number {
-    return this._height;
-  }
-
-  /**
-   * The above function sets the value of the height property.
-   * @param {number} value - The value parameter is a number that represents the new height value to be
-   * set.
-   */
-  set height(value: number) {
-    this._height = value;
   }
 }
 
@@ -67,10 +48,23 @@ export class AVLTree<
     K = any,
     V = any,
     R = object,
-    NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>
+    MK = any,
+    MV = any,
+    MR = object,
+    NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
+    TREE extends AVLTree<K, V, R, MK, MV, MR, NODE, TREE> = AVLTree<
+      K,
+      V,
+      R,
+      MK,
+      MV,
+      MR,
+      NODE,
+      AVLTreeNested<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 a constructor function for an AVLTree class that initializes the tree with keys, nodes,
@@ -102,25 +96,21 @@ export class AVLTree<
   }
 
   /**
-   * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
-   * options.
-   * @param [options] - The `options` parameter in the `createTree` function is an object that contains
-   * configuration options for creating an AVL tree. These options can include properties such as
-   * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
-   * creates a
-   * @returns An AVLTree object is being returned with the specified options and properties inherited
-   * from the current object.
+   * The function creates a new AVL tree with the specified options and returns it.
+   * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
+   * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
+   * being created.
+   * @returns a new AVLTree object.
    */
-  // @ts-ignore
-  override createTree(options?: AVLTreeOptions<K, V, R>) {
-    return new AVLTree<K, V, R, NODE>([], {
+  override createTree(options?: AVLTreeOptions<K, V, R>): TREE {
+    return new AVLTree<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;
   }
 
   /**
@@ -177,12 +167,11 @@ export class AVLTree<
     return deletedResults;
   }
 
-  // @ts-ignore
-  override map<MK, MV, MR>(
+  override map(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: AVLTreeOptions<MK, MV, MR>,
     thisArg?: any
-  ) {
+  ): AVLTree<MK, MV, MR> {
     const newTree = new AVLTree<MK, MV, MR>([], options);
     let index = 0;
     for (const [key, value] of this) {
@@ -279,7 +268,7 @@ export class AVLTree<
   protected _balanceLL(A: NODE): void {
     const parentOfA = A.parent;
     const B = A.left;
-    A.parent = B;
+    if (B !== null) A.parent = B;
     if (B && B.right) {
       B.right.parent = A;
     }
@@ -316,12 +305,12 @@ export class AVLTree<
     if (B) {
       C = B.right;
     }
-    if (A) A.parent = C;
-    if (B) B.parent = C;
+    if (A && C !== null) A.parent = C;
+    if (B && C !== null) B.parent = C;
 
     if (C) {
       if (C.left) {
-        C.left.parent = B;
+        if (B !== null) C.left.parent = B;
       }
       if (C.right) {
         C.right.parent = A;
@@ -363,7 +352,7 @@ export class AVLTree<
   protected _balanceRR(A: NODE): void {
     const parentOfA = A.parent;
     const B = A.right;
-    A.parent = B;
+    if (B !== null) A.parent = B;
     if (B) {
       if (B.left) {
         B.left.parent = A;
@@ -406,15 +395,15 @@ export class AVLTree<
       C = B.left;
     }
 
-    A.parent = C;
-    if (B) B.parent = C;
+    if (C !== null) A.parent = C;
+    if (B && C !== null) B.parent = C;
 
     if (C) {
       if (C.left) {
         C.left.parent = A;
       }
       if (C.right) {
-        C.right.parent = B;
+        if (B !== null) C.right.parent = B;
       }
       C.parent = parentOfA;
     }

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

@@ -8,6 +8,7 @@
 
 import {
   BinaryTreeDeleteResult,
+  BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BinaryTreePrintOptions,
@@ -22,6 +23,7 @@ import {
   NodeDisplayLayout,
   NodePredicate,
   OptNodeOrNull,
+  type RBTNColor,
   ToEntryFn
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -51,7 +53,7 @@ export class BinaryTreeNode<
     this.value = value;
   }
 
-  protected _left?: OptNodeOrNull<NODE>;
+  _left?: OptNodeOrNull<NODE>;
 
   get left(): OptNodeOrNull<NODE> {
     return this._left;
@@ -64,7 +66,7 @@ export class BinaryTreeNode<
     this._left = v;
   }
 
-  protected _right?: OptNodeOrNull<NODE>;
+  _right?: OptNodeOrNull<NODE>;
 
   get right(): OptNodeOrNull<NODE> {
     return this._right;
@@ -77,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) {
@@ -104,10 +136,23 @@ export class BinaryTree<
     K = any,
     V = any,
     R = object,
-    NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>
+    MK = any,
+    MV = any,
+    MR = object,
+    NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
+    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>
+  implements IBinaryTree<K, V, R, MK, MV, MR, NODE, TREE>
 {
   iterationType: IterationType = 'ITERATIVE';
 
@@ -186,26 +231,63 @@ export class BinaryTree<
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `createTree` function creates a new binary tree based on the provided options.
-   * @param [options] - The `options` parameter in the `createTree` method is of type
-   * `BinaryTreeOptions<K, V, R>`. This type likely contains configuration options for creating a
-   * binary tree, such as the iteration type, whether the tree is in map mode, and functions for
-   * converting entries.
-   * @returns The `createTree` method is returning an instance of the `BinaryTree` class with the
-   * provided options. The method is creating a new `BinaryTree` object with an empty array as the
-   * initial data, and then setting various options such as `iterationType`, `isMapMode`, and
-   * `toEntryFn` based on the current object's properties and the provided `options`. Finally, it
+   * The function creates a binary tree with the specified options.
+   * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
+   * that allows you to provide partial configuration options for creating a binary tree. It is of type
+   * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
+   * of properties
+   * @returns A new instance of a binary tree with the specified options is being returned.
    */
-  createTree(options?: BinaryTreeOptions<K, V, R>): typeof this {
-    return new BinaryTree<K, V, R>([], {
+  createTree(options?: BinaryTreeOptions<K, V, R>): TREE {
+    return new BinaryTree<K, V, R, MK, MV, MR, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       toEntryFn: this._toEntryFn,
       ...options
-    }) as unknown as typeof this;
+    }) as TREE;
+  }
+
+  /**
+   * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+   * or returns null.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+   * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+   * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
+   * node, an entry
+   * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
+   * an optional parameter of type `V`. It represents the value associated with the key in the node
+   * being created. If a `value` is provided, it will be used when creating the node. If
+   * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+   * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
+   * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
+   * value.
+   */
+  protected _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V
+  ): [OptNodeOrNull<NODE>, V | undefined] {
+    if (keyNodeEntryOrRaw === undefined) return [undefined, undefined];
+    if (keyNodeEntryOrRaw === null) return [null, undefined];
+
+    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+
+    if (this.isEntry(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = keyNodeEntryOrRaw;
+      if (key === undefined) return [undefined, undefined];
+      else if (key === null) return [null, undefined];
+      const finalValue = value ?? entryValue;
+      return [this.createNode(key, finalValue), finalValue];
+    }
+
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
+    }
+
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
+
+    return [undefined, undefined];
   }
 
   /**
@@ -490,7 +572,7 @@ export class BinaryTree<
    * elements from the other tree.
    * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
    */
-  merge(anotherTree: this) {
+  merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>) {
     this.addMany(anotherTree, []);
   }
 
@@ -1599,7 +1681,7 @@ export class BinaryTree<
    * original tree using breadth-first search (bfs), and adds the nodes to the new tree. If a node in
    * the original tree is null, a null node is added to the cloned tree. If a node
    */
-  clone() {
+  clone(): TREE {
     const cloned = this.createTree();
     this.bfs(
       node => {
@@ -1663,11 +1745,11 @@ export class BinaryTree<
    * @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<MK, MV, MR>(
+  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) {
@@ -1736,49 +1818,6 @@ export class BinaryTree<
     console.log(this.toVisual(startNode, options));
   }
 
-  /**
-   * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-   * or returns null.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-   * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-   * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
-   * node, an entry
-   * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-   * an optional parameter of type `V`. It represents the value associated with the key in the node
-   * being created. If a `value` is provided, it will be used when creating the node. If
-   * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-   * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-   * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-   * value.
-   */
-  protected _keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V
-  ): [OptNodeOrNull<NODE>, V | undefined] {
-    if (keyNodeEntryOrRaw === undefined) return [undefined, undefined];
-    if (keyNodeEntryOrRaw === null) return [null, undefined];
-
-    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-
-    if (this.isEntry(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = keyNodeEntryOrRaw;
-      if (key === undefined) return [undefined, undefined];
-      else if (key === null) return [null, undefined];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue), finalValue];
-    }
-
-    if (this.isRaw(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
-      const finalValue = value ?? entryValue;
-      if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
-    }
-
-    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
-
-    return [undefined, undefined];
-  }
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)