heap-typed 1.52.5 → 1.52.8

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

@@ -4,8 +4,8 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 const bst_1 = require("./bst");
@@ -52,7 +52,7 @@ 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 keysOrNodesOrEntriesOrRawElements - The `keysOrNodesOrEntriesOrRawElements` parameter is an
+     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` 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
@@ -60,10 +60,10 @@ class AVLTree extends bst_1.BST {
      * keys), `allowDuplicates` (a boolean indicating whether duplicate keys are allowed), and
      * `nodeBuilder` (
      */
-    constructor(keysOrNodesOrEntriesOrRawElements = [], options) {
+    constructor(keysOrNodesOrEntriesOrRaws = [], options) {
         super([], options);
-        if (keysOrNodesOrEntriesOrRawElements)
-            super.addMany(keysOrNodesOrEntriesOrRawElements);
+        if (keysOrNodesOrEntriesOrRaws)
+            super.addMany(keysOrNodesOrEntriesOrRaws);
     }
     /**
      * The function creates a new AVL tree node with the given key and value.
@@ -85,17 +85,17 @@ class AVLTree extends bst_1.BST {
      * @returns a new AVLTree object.
      */
     createTree(options) {
-        return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
+        return new AVLTree([], Object.assign({ iterationType: this.iterationType, comparator: this._comparator, toEntryFn: this._toEntryFn }, options));
     }
     /**
      * The function checks if the input is an instance of AVLTreeNode.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRawElement` is
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
      * an instance of the `AVLTreeNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRawElement) {
-        return keyOrNodeOrEntryOrRawElement instanceof AVLTreeNode;
+    isNode(keyOrNodeOrEntryOrRaw) {
+        return keyOrNodeOrEntryOrRaw instanceof AVLTreeNode;
     }
     /**
      * Time Complexity: O(log n)
@@ -103,36 +103,36 @@ class AVLTree extends bst_1.BST {
      *
      * The function overrides the add method of a class and inserts a key-value pair into a data
      * structure, then balances the path.
-     * @param {R | BTNKeyOrNodeOrEntry<K, V, NODE>} keyOrNodeOrEntryOrRawElement - The parameter
-     * `keyOrNodeOrEntryOrRawElement` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
+     * `keyOrNodeOrEntryOrRaw` can accept values of type `R`, `BTNKeyOrNodeOrEntry<K, V, NODE>`, or
      * `RawElement`.
      * @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(keyOrNodeOrEntryOrRawElement, value) {
-        if (keyOrNodeOrEntryOrRawElement === null)
+    add(keyOrNodeOrEntryOrRaw, value) {
+        if (keyOrNodeOrEntryOrRaw === null)
             return false;
-        const inserted = super.add(keyOrNodeOrEntryOrRawElement, value);
+        const inserted = super.add(keyOrNodeOrEntryOrRaw, value);
         if (inserted)
-            this._balancePath(keyOrNodeOrEntryOrRawElement);
+            this._balancePath(keyOrNodeOrEntryOrRaw);
         return inserted;
     }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The function overrides the delete method of a binary tree class and performs additional operations
-     * to balance the tree after deletion.
-     * @param identifier - The `identifier` parameter is the value or condition used to identify the
-     * node(s) to be deleted from the binary tree. It can be of any type that is compatible with the
-     * binary tree's node type.
-     * @param {C} callback - The `callback` parameter is a function that will be used to determine if a
-     * node should be deleted or not. It is optional and has a default value of `this._DEFAULT_CALLBACK`.
-     * @returns The method is returning an array of BinaryTreeDeleteResult<NODE> objects.
+     * The function overrides the delete method in a TypeScript class, performs deletion, and then
+     * balances the tree if necessary.
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R | BTNPredicate<NODE>} predicate - The `predicate`
+     * 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(identifier, callback = this._DEFAULT_CALLBACK) {
-        const deletedResults = super.delete(identifier, callback);
+    delete(predicate) {
+        const deletedResults = super.delete(predicate);
         for (const { needBalanced } of deletedResults) {
             if (needBalanced) {
                 this._balancePath(needBalanced);
@@ -298,8 +298,10 @@ class AVLTree extends bst_1.BST {
             C.right = A;
         }
         this._updateHeight(A);
-        B && this._updateHeight(B);
-        C && this._updateHeight(C);
+        if (B)
+            this._updateHeight(B);
+        if (C)
+            this._updateHeight(C);
     }
     /**
      * Time Complexity: O(1)
@@ -337,7 +339,8 @@ class AVLTree extends bst_1.BST {
             B.left = A;
         }
         this._updateHeight(A);
-        B && this._updateHeight(B);
+        if (B)
+            this._updateHeight(B);
     }
     /**
      * Time Complexity: O(1)
@@ -388,8 +391,10 @@ class AVLTree extends bst_1.BST {
         if (C)
             C.right = B;
         this._updateHeight(A);
-        B && this._updateHeight(B);
-        C && this._updateHeight(C);
+        if (B)
+            this._updateHeight(B);
+        if (C)
+            this._updateHeight(C);
     }
     /**
      * Time Complexity: O(log n)
@@ -397,47 +402,49 @@ 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 {R | BTNKeyOrNodeOrEntry<K, V, NODE>} node - The `node` parameter can be of type `R` or
+     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} node - The `node` parameter can be of type `R` or
      * `BTNKeyOrNodeOrEntry<K, V, NODE>`.
      */
     _balancePath(node) {
         node = this.ensureNode(node);
-        const path = this.getPathToRoot(node, false); // first O(log n) + O(log n)
+        const path = this.getPathToRoot(node => node, node, false); // first O(log n) + O(log n)
         for (let i = 0; i < path.length; i++) {
             // second O(log n)
             const A = path[i];
-            // Update Heights: After inserting a node, backtrack from the insertion point to the root node, updating the height of each node along the way.
-            this._updateHeight(A); // first O(1)
-            // Check Balance: Simultaneously with height updates, check if each node violates the balance property of an AVL tree.
-            // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
-            switch (this._balanceFactor(A) // second O(1)
-            ) {
-                case -2:
-                    if (A && A.left) {
-                        if (this._balanceFactor(A.left) <= 0) {
-                            // second O(1)
-                            // Left Rotation (LL Rotation): When the inserted node is in the left subtree of the left subtree, causing an imbalance.
-                            this._balanceLL(A);
-                        }
-                        else {
-                            // Left-Right Rotation (LR Rotation): When the inserted node is in the right subtree of the left subtree, causing an imbalance.
-                            this._balanceLR(A);
+            if (A) {
+                // Update Heights: After inserting a node, backtrack from the insertion point to the root node, updating the height of each node along the way.
+                this._updateHeight(A); // first O(1)
+                // Check Balance: Simultaneously with height updates, check if each node violates the balance property of an AVL tree.
+                // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
+                switch (this._balanceFactor(A) // second O(1)
+                ) {
+                    case -2:
+                        if (A && A.left) {
+                            if (this._balanceFactor(A.left) <= 0) {
+                                // second O(1)
+                                // Left Rotation (LL Rotation): When the inserted node is in the left subtree of the left subtree, causing an imbalance.
+                                this._balanceLL(A);
+                            }
+                            else {
+                                // Left-Right Rotation (LR Rotation): When the inserted node is in the right subtree of the left subtree, causing an imbalance.
+                                this._balanceLR(A);
+                            }
                         }
-                    }
-                    break;
-                case +2:
-                    if (A && A.right) {
-                        if (this._balanceFactor(A.right) >= 0) {
-                            // Right Rotation (RR Rotation): When the inserted node is in the right subtree of the right subtree, causing an imbalance.
-                            this._balanceRR(A);
+                        break;
+                    case +2:
+                        if (A && A.right) {
+                            if (this._balanceFactor(A.right) >= 0) {
+                                // Right Rotation (RR Rotation): When the inserted node is in the right subtree of the right subtree, causing an imbalance.
+                                this._balanceRR(A);
+                            }
+                            else {
+                                // Right-Left Rotation (RL Rotation): When the inserted node is in the left subtree of the right subtree, causing an imbalance.
+                                this._balanceRL(A);
+                            }
                         }
-                        else {
-                            // Right-Left Rotation (RL Rotation): When the inserted node is in the left subtree of the right subtree, causing an imbalance.
-                            this._balanceRL(A);
-                        }
-                    }
+                }
+                // TODO So far, no sure if this is necessary that Recursive Repair: Once rotation operations are executed, it may cause imbalance issues at higher levels of the tree. Therefore, you need to recursively check and repair imbalance problems upwards until you reach the root node.
             }
-            // TODO So far, no sure if this is necessary that Recursive Repair: Once rotation operations are executed, it may cause imbalance issues at higher levels of the tree. Therefore, you need to recursively check and repair imbalance problems upwards until you reach the root node.
         }
     }
     /**

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

@@ -4,8 +4,8 @@ exports.BinaryIndexedTree = void 0;
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Pablo Zeng
+ * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
 const utils_1 = require("../../utils");