doubly-linked-list-typed 1.53.9 → 1.54.0

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)