heap-typed 1.49.5 → 1.49.6

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

@@ -68,15 +68,15 @@ exports.BinaryTreeNode = BinaryTreeNode;
  */
 class BinaryTree extends base_1.IterableEntryBase {
     /**
-     * The constructor function initializes a binary tree object with optional elements and options.
-     * @param [elements] - An optional iterable of BTNExemplar objects. These objects represent the
-     * elements to be added to the binary tree.
+     * The constructor function initializes a binary tree object with optional nodes and options.
+     * @param [nodes] - An optional iterable of KeyOrNodeOrEntry objects. These objects represent the
+     * nodes to be added to the binary tree.
      * @param [options] - The `options` parameter is an optional object that can contain additional
      * configuration options for the binary tree. In this case, it is of type
      * `Partial<BinaryTreeOptions>`, which means that not all properties of `BinaryTreeOptions` are
      * required.
      */
-    constructor(elements, options) {
+    constructor(nodes, options) {
         super();
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._extractor = (key) => Number(key);
@@ -91,8 +91,8 @@ class BinaryTree extends base_1.IterableEntryBase {
             }
         }
         this._size = 0;
-        if (elements)
-            this.addMany(elements);
+        if (nodes)
+            this.addMany(nodes);
     }
     get extractor() {
         return this._extractor;
@@ -123,30 +123,22 @@ class BinaryTree extends base_1.IterableEntryBase {
         return new BinaryTree([], Object.assign({ iterationType: this.iterationType }, options));
     }
     /**
-     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNExemplar<K, V,N>`.
-     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
-     */
-    isNode(exemplar) {
-        return exemplar instanceof BinaryTreeNode;
-    }
-    /**
-     * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNExemplar<K, V, N>`.
+     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-     * `exemplarToNode` function. It represents the value associated with the exemplar node. If no value
+     * `exemplarToNode` function. It represents the value associated with the keyOrNodeOrEntry node. If no value
      * is provided, it will be `undefined`.
      * @returns a value of type N (node), or null, or undefined.
      */
-    exemplarToNode(exemplar, value) {
-        if (exemplar === undefined)
+    exemplarToNode(keyOrNodeOrEntry, value) {
+        if (keyOrNodeOrEntry === undefined)
             return;
         let node;
-        if (exemplar === null) {
+        if (keyOrNodeOrEntry === null) {
             node = null;
         }
-        else if (this.isEntry(exemplar)) {
-            const [key, value] = exemplar;
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            const [key, value] = keyOrNodeOrEntry;
             if (key === undefined) {
                 return;
             }
@@ -157,25 +149,108 @@ class BinaryTree extends base_1.IterableEntryBase {
                 node = this.createNode(key, value);
             }
         }
-        else if (this.isNode(exemplar)) {
-            node = exemplar;
+        else if (this.isNode(keyOrNodeOrEntry)) {
+            node = keyOrNodeOrEntry;
         }
-        else if (this.isNotNodeInstance(exemplar)) {
-            node = this.createNode(exemplar, value);
+        else if (this.isNotNodeInstance(keyOrNodeOrEntry)) {
+            node = this.createNode(keyOrNodeOrEntry, value);
         }
         else {
             return;
         }
         return node;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(log n)
+     *
+     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
+     * key, otherwise it returns the key itself.
+     * @param {K | N | null | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `N`,
+     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to be used when searching for a node by key. It has a default value of
+     * `IterationType.ITERATIVE`.
+     * @returns either the node corresponding to the given key if it is a valid node key, or the key
+     * itself if it is not a valid node key.
+     */
+    ensureNode(keyOrNodeOrEntry, iterationType = types_1.IterationType.ITERATIVE) {
+        let res;
+        if (this.isRealNode(keyOrNodeOrEntry)) {
+            res = keyOrNodeOrEntry;
+        }
+        else if (this.isEntry(keyOrNodeOrEntry)) {
+            if (keyOrNodeOrEntry[0] === null)
+                res = null;
+            else if (keyOrNodeOrEntry[0] !== undefined)
+                res = this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
+        }
+        else {
+            if (keyOrNodeOrEntry === null)
+                res = null;
+            else if (keyOrNodeOrEntry !== undefined)
+                res = this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+        }
+        return res;
+    }
+    /**
+     * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,N>`.
+     * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the class N.
+     */
+    isNode(keyOrNodeOrEntry) {
+        return keyOrNodeOrEntry instanceof BinaryTreeNode;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
-     * @param kne - BTNExemplar<K, V,N> - A generic type representing a node in a binary tree. It has
+     * @param keyOrNodeOrEntry - KeyOrNodeOrEntry<K, V,N> - A generic type representing a node in a binary tree. It has
      * two type parameters V and N, representing the value and node type respectively.
      * @returns a boolean value.
      */
-    isEntry(kne) {
-        return Array.isArray(kne) && kne.length === 2;
+    isEntry(keyOrNodeOrEntry) {
+        return Array.isArray(keyOrNodeOrEntry) && keyOrNodeOrEntry.length === 2;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(log n)
+     */
+    /**
+     * The function checks if a given node is a real node by verifying if it is an instance of
+     * BinaryTreeNode and its key is not NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isRealNode(node) {
+        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
+    }
+    /**
+     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNIL(node) {
+        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
+    }
+    /**
+     * The function checks if a given node is a real node or null.
+     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
+     * @returns a boolean value.
+     */
+    isNodeOrNull(node) {
+        return this.isRealNode(node) || node === null;
+    }
+    /**
+     * The function "isNotNodeInstance" checks if a potential key is a K.
+     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
+     * data type.
+     * @returns a boolean value indicating whether the potentialKey is of type number or not.
+     */
+    isNotNodeInstance(potentialKey) {
+        return !(potentialKey instanceof BinaryTreeNode);
     }
     /**
      * Time Complexity O(log n) - O(n)
@@ -194,12 +269,12 @@ class BinaryTree extends base_1.IterableEntryBase {
     add(keyOrNodeOrEntry, value) {
         const newNode = this.exemplarToNode(keyOrNodeOrEntry, value);
         if (newNode === undefined)
-            return;
+            return false;
         // If the tree is empty, directly set the new node as the root node
         if (!this.root) {
             this._root = newNode;
             this._size = 1;
-            return newNode;
+            return true;
         }
         const queue = new queue_1.Queue([this.root]);
         let potentialParent; // Record the parent node of the potential insertion location
@@ -210,7 +285,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             // Check for duplicate keys when newNode is not null
             if (newNode !== null && cur.key === newNode.key) {
                 this._replaceNode(cur, newNode);
-                return newNode; // If duplicate keys are found, no insertion is performed
+                return true; // If duplicate keys are found, no insertion is performed
             }
             // Record the first possible insertion location found
             if (potentialParent === undefined && (cur.left === undefined || cur.right === undefined)) {
@@ -233,9 +308,9 @@ class BinaryTree extends base_1.IterableEntryBase {
                 potentialParent.right = newNode;
             }
             this._size++;
-            return newNode;
+            return true;
         }
-        return undefined; // If the insertion position cannot be found, return undefined
+        return false; // If the insertion position cannot be found, return undefined
     }
     /**
      * Time Complexity: O(k log n) - O(k * n)
@@ -246,20 +321,20 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(k log n) - O(k * n)
      * Space Complexity: O(1)
      *
-     * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+     * The `addMany` function takes in a collection of keysOrNodesOrEntries and an optional collection of values, and
      * adds each node with its corresponding value to the data structure.
-     * @param nodes - An iterable collection of BTNExemplar objects.
+     * @param keysOrNodesOrEntries - An iterable collection of KeyOrNodeOrEntry objects.
      * @param [values] - An optional iterable of values that will be assigned to each node being added.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(nodes, values) {
+    addMany(keysOrNodesOrEntries, values) {
         // TODO not sure addMany not be run multi times
         const inserted = [];
         let valuesIterator;
         if (values) {
             valuesIterator = values[Symbol.iterator]();
         }
-        for (const kne of nodes) {
+        for (const keyOrNodeOrEntry of keysOrNodesOrEntries) {
             let value = undefined;
             if (valuesIterator) {
                 const valueResult = valuesIterator.next();
@@ -267,17 +342,30 @@ class BinaryTree extends base_1.IterableEntryBase {
                     value = valueResult.value;
                 }
             }
-            inserted.push(this.add(kne, value));
+            inserted.push(this.add(keyOrNodeOrEntry, value));
         }
         return inserted;
     }
     /**
-     * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
+     * Time Complexity: O(k * n)
      * Space Complexity: O(1)
+     * "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
      */
-    refill(nodesOrKeysOrEntries, values) {
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `refill` function clears the current data and adds new key-value pairs to the data structure.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries. These can be of type
+     * KeyOrNodeOrEntry<K, V, N>.
+     * @param [values] - The `values` parameter is an optional iterable that contains the values to be
+     * associated with the keys or nodes or entries in the `keysOrNodesOrEntries` parameter. If provided,
+     * the values will be associated with the corresponding keys or nodes or entries in the
+     * `keysOrNodesOrEntries` iterable
+     */
+    refill(keysOrNodesOrEntries, values) {
         this.clear();
-        this.addMany(nodesOrKeysOrEntries, values);
+        this.addMany(keysOrNodesOrEntries, values);
     }
     /**
      * Time Complexity: O(n)
@@ -351,24 +439,24 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Space Complexity: O(1)
      *
      * The function calculates the depth of a given node in a binary tree.
-     * @param {K | N | null | undefined} distNode - The `distNode` parameter represents the node in
+     * @param {K | N | null | undefined} dist - The `dist` parameter represents the node in
      * the binary tree whose depth we want to find. It can be of type `K`, `N`, `null`, or
      * `undefined`.
      * @param {K | N | null | undefined} beginRoot - The `beginRoot` parameter is the starting node
      * from which we want to calculate the depth. It can be either a `K` (binary tree node key) or
      * `N` (binary tree node) or `null` or `undefined`. If no value is provided for `beginRoot
-     * @returns the depth of the `distNode` relative to the `beginRoot`.
+     * @returns the depth of the `dist` relative to the `beginRoot`.
      */
-    getDepth(distNode, beginRoot = this.root) {
-        distNode = this.ensureNode(distNode);
+    getDepth(dist, beginRoot = this.root) {
+        dist = this.ensureNode(dist);
         beginRoot = this.ensureNode(beginRoot);
         let depth = 0;
-        while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
-            if (distNode === beginRoot) {
+        while (dist === null || dist === void 0 ? void 0 : dist.parent) {
+            if (dist === beginRoot) {
                 return depth;
             }
             depth++;
-            distNode = distNode.parent;
+            dist = dist.parent;
         }
         return depth;
     }
@@ -565,6 +653,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * Time Complexity: O(n)
+     * Space Complexity: O(log n).
      *
      * The function checks if a Binary Tree Node with a specific identifier exists in the tree.
      * @param {ReturnType<C> | null | undefined} identifier - The `identifier` parameter is the value
@@ -662,24 +751,6 @@ class BinaryTree extends base_1.IterableEntryBase {
             }
         }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     */
-    /**
-     * The function `ensureNode` returns the node corresponding to the given key if it is a valid node
-     * key, otherwise it returns the key itself.
-     * @param {K | N | null | undefined} key - The `key` parameter can be of type `K`, `N`,
-     * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to be used when searching for a node by key. It has a default value of
-     * `IterationType.ITERATIVE`.
-     * @returns either the node corresponding to the given key if it is a valid node key, or the key
-     * itself if it is not a valid node key.
-     */
-    ensureNode(key, iterationType = types_1.IterationType.ITERATIVE) {
-        return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -709,10 +780,13 @@ class BinaryTree extends base_1.IterableEntryBase {
         return (_b = (_a = this.getNode(identifier, callback, beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : undefined;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Clear the binary tree, removing all nodes.
      */
     clear() {
@@ -720,6 +794,13 @@ class BinaryTree extends base_1.IterableEntryBase {
         this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * Check if the binary tree is empty.
      * @returns {boolean} - True if the binary tree is empty, false otherwise.
      */
@@ -757,7 +838,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * Time Complexity: O(log n)
-     * Space Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(log n)
@@ -853,7 +934,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * possible values:
      * @returns a boolean value.
      */
-    isSubtreeBST(beginRoot, iterationType = this.iterationType) {
+    isBST(beginRoot = this.root, iterationType = this.iterationType) {
         // TODO there is a bug
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
@@ -867,46 +948,34 @@ class BinaryTree extends base_1.IterableEntryBase {
                     return false;
                 return dfs(cur.left, min, numKey) && dfs(cur.right, numKey, max);
             };
-            return dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            const isStandardBST = dfs(beginRoot, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
+            const isInverseBST = dfs(beginRoot, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
+            return isStandardBST || isInverseBST;
         }
         else {
-            const stack = [];
-            let prev = Number.MIN_SAFE_INTEGER, curr = beginRoot;
-            while (curr || stack.length > 0) {
-                while (curr) {
-                    stack.push(curr);
-                    curr = curr.left;
+            const checkBST = (checkMax = false) => {
+                const stack = [];
+                let prev = checkMax ? Number.MAX_SAFE_INTEGER : Number.MIN_SAFE_INTEGER;
+                // @ts-ignore
+                let curr = beginRoot;
+                while (curr || stack.length > 0) {
+                    while (curr) {
+                        stack.push(curr);
+                        curr = curr.left;
+                    }
+                    curr = stack.pop();
+                    const numKey = this.extractor(curr.key);
+                    if (!curr || (!checkMax && prev >= numKey) || (checkMax && prev <= numKey))
+                        return false;
+                    prev = numKey;
+                    curr = curr.right;
                 }
-                curr = stack.pop();
-                const numKey = this.extractor(curr.key);
-                if (!curr || prev >= numKey)
-                    return false;
-                prev = numKey;
-                curr = curr.right;
-            }
-            return true;
+                return true;
+            };
+            const isStandardBST = checkBST(false), isInverseBST = checkBST(true);
+            return isStandardBST || isInverseBST;
         }
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The function checks if a binary tree is a binary search tree.
-     * @param iterationType - The parameter "iterationType" is used to specify the type of iteration to
-     * be used when checking if the binary tree is a binary search tree (BST). It is an optional
-     * parameter with a default value of "this.iterationType". The value of "this.iterationType" is
-     * expected to be
-     * @returns a boolean value.
-     */
-    isBST(iterationType = this.iterationType) {
-        if (this.root === null)
-            return true;
-        return this.isSubtreeBST(this.root, iterationType);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(log n)
@@ -926,7 +995,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * whether to include null values in the traversal. If `includeNull` is set to `true`, the
      * traversal will include null values, otherwise it will skip them.
      * @returns The function `subTreeTraverse` returns an array of values that are the result of invoking
-     * the `callback` function on each node in the subtree. The type of the array elements is determined
+     * the `callback` function on each node in the subtree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     subTreeTraverse(callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType, includeNull = false) {
@@ -969,44 +1038,6 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(log n)
-     */
-    /**
-     * The function checks if a given node is a real node by verifying if it is an instance of
-     * BinaryTreeNode and its key is not NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isRealNode(node) {
-        return node instanceof BinaryTreeNode && String(node.key) !== 'NaN';
-    }
-    /**
-     * The function checks if a given node is a BinaryTreeNode instance and has a key value of NaN.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNIL(node) {
-        return node instanceof BinaryTreeNode && String(node.key) === 'NaN';
-    }
-    /**
-     * The function checks if a given node is a real node or null.
-     * @param {any} node - The parameter `node` is of type `any`, which means it can be any data type.
-     * @returns a boolean value.
-     */
-    isNodeOrNull(node) {
-        return this.isRealNode(node) || node === null;
-    }
-    /**
-     * The function "isNotNodeInstance" checks if a potential key is a K.
-     * @param {any} potentialKey - The potentialKey parameter is of type any, which means it can be any
-     * data type.
-     * @returns a boolean value indicating whether the potentialKey is of type number or not.
-     */
-    isNotNodeInstance(potentialKey) {
-        return !(potentialKey instanceof BinaryTreeNode);
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1328,7 +1359,12 @@ class BinaryTree extends base_1.IterableEntryBase {
     }
     /**
      * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
      * The `morris` function performs a depth-first traversal on a binary tree using the Morris traversal
      * algorithm.
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
@@ -1341,7 +1377,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * for the traversal. It can be specified as a key, a node object, or `null`/`undefined` to indicate
      * the root of the tree. If no value is provided, the default value is the root of the tree.
      * @returns The function `morris` returns an array of values that are the result of invoking the
-     * `callback` function on each node in the binary tree. The type of the array elements is determined
+     * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
     morris(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
@@ -1454,8 +1490,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new tree by iterating over the elements of the current tree and
-     * adding only the elements that satisfy the given predicate function.
+     * The `filter` function creates a new tree by iterating over the nodes of the current tree and
+     * adding only the nodes that satisfy the given predicate function.
      * @param predicate - The `predicate` parameter is a function that takes three arguments: `value`,
      * `key`, and `index`. It should return a boolean value indicating whether the pair should be
      * included in the filtered tree or not.
@@ -1512,6 +1548,13 @@ class BinaryTree extends base_1.IterableEntryBase {
     // // }
     //
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The `print` function is used to display a binary tree structure in a visually appealing way.
      * @param {K | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `K | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the