red-black-tree-typed 1.53.7 → 1.54.2

package/dist/data-structures/binary-tree/avl-tree.js

@@ -11,31 +11,37 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
     /**
-     * The constructor function initializes a new instance of a class with a key and an optional value,
-     * and sets the height property to 0.
-     * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-     * constructor. It is used to initialize the key property of the object being created.
-     * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
-     * value associated with the key in the constructor.
+     * This TypeScript constructor function initializes an instance with a key and an optional value.
+     * @param {K} key - The `key` parameter is typically used to uniquely identify an object or element
+     * within a data structure. It serves as a reference or identifier for accessing or manipulating the
+     * associated value or data.
+     * @param {V} [value] - The `value` parameter in the constructor is optional, meaning it does not
+     * have to be provided when creating an instance of the class. If a value is not provided, it will
+     * default to `undefined`.
      */
     constructor(key, value) {
         super(key, value);
-        this._height = 0;
+        this.parent = undefined;
+        this._left = undefined;
+        this._right = undefined;
     }
-    /**
-     * The function returns the value of the height property.
-     * @returns The height of the object.
-     */
-    get height() {
-        return this._height;
+    get left() {
+        return this._left;
     }
-    /**
-     * 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) {
-        this._height = value;
+    set left(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._left = v;
+    }
+    get right() {
+        return this._right;
+    }
+    set right(v) {
+        if (v) {
+            v.parent = this;
+        }
+        this._right = v;
     }
 }
 exports.AVLTreeNode = AVLTreeNode;
@@ -50,15 +56,15 @@ exports.AVLTreeNode = AVLTreeNode;
  */
 class AVLTree extends bst_1.BST {
     /**
-     * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
-     * entries, or raw elements.
-     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
-     * iterable object that can contain either keys, nodes, entries, or raw elements. These elements will
-     * be used to initialize the AVLTree.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the AVLTree. It can include properties such as `compareFn` (a function used to compare
-     * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
-     * `nodeBuilder` (
+     * This TypeScript constructor initializes an AVLTree with keys, nodes, entries, or raw data provided
+     * in an iterable format.
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter in the constructor is an
+     * iterable that can contain either `BTNRep<K, V, AVLTreeNode<K, V>>` objects or `R` objects. It is
+     * used to initialize the AVLTree with key-value pairs or raw data entries. If provided
+     * @param [options] - The `options` parameter in the constructor is of type `AVLTreeOptions<K, V,
+     * R>`. It is an optional parameter that allows you to specify additional options for configuring the
+     * AVL tree. These options could include things like custom comparators, initial capacity, or any
+     * other configuration settings specific
      */
     constructor(keysNodesEntriesOrRaws = [], options) {
         super([], options);
@@ -66,18 +72,24 @@ class AVLTree extends bst_1.BST {
             super.addMany(keysNodesEntriesOrRaws);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function creates a new AVL tree node with the given key and value.
      * @param {K} key - The key parameter is of type K, which represents the key of the node being
      * created.
      * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
      * value associated with the key in the node being created.
      * @returns The method is returning a new instance of the AVLTreeNode class, casted as the generic
-     * type NODE.
+     * type AVLTreeNode<K, V>.
      */
     createNode(key, value) {
         return new AVLTreeNode(key, this._isMapMode ? undefined : value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * 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
@@ -85,54 +97,56 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, extractComparable: this._extractComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, isMapMode: this._isMapMode, specifyComparable: this._specifyComparable, toEntryFn: this._toEntryFn, isReverse: this._isReverse }, options));
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can be of type `R` or `BTNRep<K, V, AVLTreeNode<K, V>>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeOrEntry` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyNodeEntryOrRaw) {
-        return keyNodeEntryOrRaw instanceof AVLTreeNode;
+    isNode(keyNodeOrEntry) {
+        return keyNodeOrEntry instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
-     * `keyNodeEntryOrRaw` can accept values of type `R`, `BTNRep<K, V, NODE>`, or
-     * `RawElement`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The parameter
+     * `keyNodeOrEntry` can accept values of type `R`, `BTNRep<K, V, AVLTreeNode<K, V>>`
      * @param {V} [value] - The `value` parameter is an optional value that you want to associate with
      * the key or node being added to the data structure.
      * @returns The method is returning a boolean value.
      */
-    add(keyNodeEntryOrRaw, value) {
-        if (keyNodeEntryOrRaw === null)
+    add(keyNodeOrEntry, value) {
+        if (keyNodeOrEntry === null)
             return false;
-        const inserted = super.add(keyNodeEntryOrRaw, value);
+        const inserted = super.add(keyNodeOrEntry, value);
         if (inserted)
-            this._balancePath(keyNodeEntryOrRaw);
+            this._balancePath(keyNodeOrEntry);
         return inserted;
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(log n)
      *
      * The function overrides the delete method in a TypeScript class, performs deletion, and then
      * balances the tree if necessary.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `keyNodeEntryOrRaw`
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} keyNodeOrEntry - The `keyNodeOrEntry`
      * parameter in the `override delete` method can be one of the following types:
      * @returns The `delete` method is being overridden in this code snippet. It first calls the `delete`
      * method from the superclass (presumably a parent class) with the provided `predicate`, which could
      * be a key, node, entry, or a custom predicate. The result of this deletion operation is stored in
      * `deletedResults`, which is an array of `BinaryTreeDeleteResult` objects.
      */
-    delete(keyNodeEntryOrRaw) {
-        const deletedResults = super.delete(keyNodeEntryOrRaw);
+    delete(keyNodeOrEntry) {
+        const deletedResults = super.delete(keyNodeOrEntry);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);
@@ -140,16 +154,57 @@ class AVLTree extends bst_1.BST {
         }
         return deletedResults;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function in TypeScript overrides the default map behavior of an AVLTree data structure
+     * by applying a callback function to each entry and creating a new AVLTree with the results.
+     * @param callback - A function that will be called for each entry in the AVLTree. It takes four
+     * arguments: the key, the value (which can be undefined), the index of the entry, and a reference to
+     * the AVLTree itself.
+     * @param [options] - The `options` parameter in the `override map` function is of type
+     * `AVLTreeOptions<MK, MV, MR>`. It is an optional parameter that allows you to specify additional
+     * options for the AVL tree being created during the mapping process. These options could include
+     * custom comparators, initial
+     * @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`) within the callback function. This can be useful when you want to access
+     * properties or
+     * @returns The `map` method is returning a new AVLTree instance (`newTree`) with the entries
+     * modified by the provided callback function.
+     */
+    map(callback, options, thisArg) {
+        const newTree = new AVLTree([], options);
+        let index = 0;
+        for (const [key, value] of this) {
+            newTree.add(callback.call(thisArg, key, value, index++, this));
+        }
+        return newTree;
+    }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The function `clone` overrides the default cloning behavior to create a deep copy of a tree
+     * structure.
+     * @returns A cloned tree object is being returned.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this._clone(cloned);
+        return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
      * The `_swapProperties` function swaps the key, value, and height properties between two nodes in a
      * binary search tree.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents either a node
-     * object (`NODE`) or a key-value pair (`R`) that is being swapped with another node.
-     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter is either an instance of
-     * `R` or an instance of `BSTNOptKeyOrNode<K, NODE>`.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} srcNode - The `srcNode` parameter represents either a node
+     * object (`AVLTreeNode<K, V>`) or a key-value pair (`R`) that is being swapped with another node.
+     * @param {BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>} destNode - The `destNode` parameter is either an instance of
+     * `R` or an instance of `BSTNOptKeyOrNode<K, AVLTreeNode<K, V>>`.
      * @returns The method is returning the `destNodeEnsured` object if both `srcNodeEnsured` and
      * `destNodeEnsured` are truthy. Otherwise, it returns `undefined`.
      */
@@ -179,7 +234,7 @@ class AVLTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function calculates the balance factor of a node in a binary tree.
-     * @param {NODE} node - The parameter "node" is of type "NODE", which likely represents a node in a
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" is of type "AVLTreeNode<K, V>", which likely represents a node in a
      * binary tree data structure.
      * @returns the balance factor of a given node. The balance factor is calculated by subtracting the
      * height of the left subtree from the height of the right subtree.
@@ -200,7 +255,7 @@ class AVLTree extends bst_1.BST {
      *
      * The function updates the height of a node in a binary tree based on the heights of its left and
      * right children.
-     * @param {NODE} node - The parameter "node" represents a node in a binary tree data structure.
+     * @param {AVLTreeNode<K, V>} node - The parameter "node" represents a node in a binary tree data structure.
      */
     _updateHeight(node) {
         if (!node.left && !node.right)
@@ -219,12 +274,13 @@ class AVLTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The `_balanceLL` function performs a left-left rotation to balance a binary search tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceLL(A) {
         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;
         }
@@ -256,7 +312,7 @@ class AVLTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The `_balanceLR` function performs a left-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceLR(A) {
         const parentOfA = A.parent;
@@ -265,13 +321,14 @@ class AVLTree extends bst_1.BST {
         if (B) {
             C = B.right;
         }
-        if (A)
+        if (A && C !== null)
             A.parent = C;
-        if (B)
+        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;
@@ -310,12 +367,13 @@ class AVLTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function `_balanceRR` performs a right-right rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceRR(A) {
         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;
@@ -349,7 +407,7 @@ class AVLTree extends bst_1.BST {
      * Space Complexity: O(1)
      *
      * The function `_balanceRL` performs a right-left rotation to balance a binary tree.
-     * @param {NODE} A - A is a node in a binary tree.
+     * @param {AVLTreeNode<K, V>} A - A is a node in a binary tree.
      */
     _balanceRL(A) {
         const parentOfA = A.parent;
@@ -358,15 +416,17 @@ class AVLTree extends bst_1.BST {
         if (B) {
             C = B.left;
         }
-        A.parent = C;
-        if (B)
+        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;
         }
@@ -404,8 +464,8 @@ class AVLTree extends bst_1.BST {
      *
      * The `_balancePath` function is used to update the heights of nodes and perform rotation operations
      * to restore balance in an AVL tree after inserting a node.
-     * @param {BTNRep<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
-     * `BTNRep<K, V, NODE>`.
+     * @param {BTNRep<K, V, AVLTreeNode<K, V>>} node - The `node` parameter can be of type `R` or
+     * `BTNRep<K, V, AVLTreeNode<K, V>>`.
      */
     _balancePath(node) {
         node = this.ensureNode(node);
@@ -455,9 +515,9 @@ class AVLTree extends bst_1.BST {
      *
      * The function replaces an old node with a new node and sets the height of the new node to be the
      * same as the old node.
-     * @param {NODE} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
+     * @param {AVLTreeNode<K, V>} oldNode - The `oldNode` parameter represents the node that needs to be replaced in
      * the data structure.
-     * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+     * @param {AVLTreeNode<K, V>} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
      * the data structure.
      * @returns The method is returning the result of calling the `_replaceNode` method from the
      * superclass, with the `oldNode` and `newNode` as arguments.

package/dist/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -1,3 +1,6 @@
+/**
+ *
+ */
 export declare class BinaryIndexedTree {
     protected readonly _freq: number;
     protected readonly _max: number;

package/dist/data-structures/binary-tree/binary-indexed-tree.js

@@ -9,6 +9,9 @@ exports.BinaryIndexedTree = void 0;
  * @license MIT License
  */
 const utils_1 = require("../../utils");
+/**
+ *
+ */
 class BinaryIndexedTree {
     /**
      * The constructor initializes the properties of an object, including default frequency, maximum