data-structure-typed 1.53.5 → 1.53.7

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

@@ -8,6 +8,7 @@
 import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BinaryTreePrintOptions, BTNEntry, BTNRep, DFSOrderPattern, EntryCallback, FamilyPosition, IterationType, NodeCallback, NodeDisplayLayout, NodePredicate, OptNodeOrNull, ToEntryFn } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { IterableEntryBase } from '../base';
+import { Range } from '../../common';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -120,6 +121,13 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * is not a node.
      */
     isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
+    /**
+     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
+     * checking if it is an object. If the parameter is an object, the function will return `true`,
+     * indicating that it is of type `R`.
+     */
     isRaw(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is R;
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
@@ -150,6 +158,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * property of the current object and returning a boolean value based on that comparison.
      */
     isNIL(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): boolean;
+    isRange(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE> | Range<K>): keyNodeEntryRawOrPredicate is Range<K>;
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
@@ -221,6 +230,15 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * corresponds to the success of adding the corresponding key or value in the input iterable.
      */
     addMany(keysNodesEntriesOrRaws: Iterable<BTNRep<K, V, NODE> | R>, values?: Iterable<V | undefined>): boolean[];
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
+     * elements from the other tree.
+     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     */
+    merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>): void;
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -250,6 +268,31 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * need to be balanced (`needBalanced`).
      */
     delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): BinaryTreeDeleteResult<NODE>[];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(k + log n)
+     *
+     * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
+     * structure based on a given predicate or key, with options to return multiple results or just one.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` parameter in the `search` function can accept three types of values:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
+     * determines whether the search should stop after finding the first matching node. If `onlyOne` is
+     * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
+     * @param {C} callback - The `callback` parameter in the `search` function is a callback function
+     * that will be called on each node that matches the search criteria. It is of type `C`, which
+     * extends `NodeCallback<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `search` function is
+     * used to specify the node from which the search operation should begin. It represents the starting
+     * point in the binary tree where the search will be performed. If no specific `startNode` is
+     * provided, the search operation will start from the root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
+     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
+     * two possible values:
+     * @returns The `search` function returns an array of values that match the provided criteria based
+     * on the search algorithm implemented within the function.
+     */
+    search<C extends NodeCallback<NODE>>(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, onlyOne?: boolean, callback?: C, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
@@ -293,20 +336,6 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * or `null` if no matching node is found.
      */
     getNode(keyNodeEntryRawOrPredicate: BTNRep<K, V, NODE> | R | NodePredicate<NODE>, startNode?: BTNRep<K, V, NODE> | R, iterationType?: IterationType): OptNodeOrNull<NODE>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
-     * @param {K} key - The `key` parameter is the value used to search for a specific node in a data
-     * structure.
-     * @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
-     * specifies how the tree nodes should be traversed when searching for a node with the given key. It
-     * is an optional parameter with a default value of `this.iterationType`.
-     * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptNodeOrNull<NODE>`).
-     */
-    getNodeByKey(key: K, iterationType?: IterationType): OptNodeOrNull<NODE>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n)
@@ -478,7 +507,7 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot<C extends NodeCallback<OptNodeOrNull<NODE>>>(callback: C | undefined, beginNode: BTNRep<K, V, NODE> | R, isReverse?: boolean): ReturnType<C>[];
+    getPathToRoot<C extends NodeCallback<OptNodeOrNull<NODE>>>(beginNode: BTNRep<K, V, NODE> | R, callback?: C, isReverse?: boolean): ReturnType<C>[];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -825,16 +854,16 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
      * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    protected _getKey(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): K | null | undefined;
+    protected _extractKey(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): K | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -851,10 +880,16 @@ export declare class BinaryTree<K = any, V = any, R = object, NODE extends Binar
      */
     protected _setValue(key: K | null | undefined, value: V | undefined): false | Map<K, V | undefined>;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearNodes function sets the root node to undefined and resets the size to 0.
      */
     protected _clearNodes(): void;
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearValues function clears all values stored in the _store object.
      */
     protected _clearValues(): void;

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

@@ -8,7 +8,7 @@
 import { isComparable, trampoline } from '../../utils';
 import { Queue } from '../queue';
 import { IterableEntryBase } from '../base';
-import { DFSOperation } from '../../constants';
+import { DFSOperation, Range } from '../../common';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -173,17 +173,14 @@ export class BinaryTree extends IterableEntryBase {
             const finalValue = value ?? entryValue;
             return [this.createNode(key, finalValue), finalValue];
         }
-        if (this.isKey(keyNodeEntryOrRaw))
-            return [this.createNode(keyNodeEntryOrRaw, value), value];
         if (this.isRaw(keyNodeEntryOrRaw)) {
-            if (this._toEntryFn) {
-                const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw);
-                const finalValue = value ?? entryValue;
-                if (this.isKey(key))
-                    return [this.createNode(key, finalValue), finalValue];
-            }
-            return [undefined, undefined];
+            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];
     }
     /**
@@ -216,15 +213,15 @@ export class BinaryTree extends IterableEntryBase {
                 return null;
             if (key === undefined)
                 return;
-            return this.getNodeByKey(key, iterationType);
+            return this.getNode(key, this._root, iterationType);
         }
         if (this._toEntryFn) {
             const [key] = this._toEntryFn(keyNodeEntryOrRaw);
             if (this.isKey(key))
-                return this.getNodeByKey(key);
+                return this.getNode(key);
         }
         if (this.isKey(keyNodeEntryOrRaw))
-            return this.getNodeByKey(keyNodeEntryOrRaw, iterationType);
+            return this.getNode(keyNodeEntryOrRaw, this._root, iterationType);
         return;
     }
     /**
@@ -241,8 +238,15 @@ export class BinaryTree extends IterableEntryBase {
     isNode(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw instanceof BinaryTreeNode;
     }
+    /**
+     * The function `isRaw` checks if the input parameter is of type `R` by verifying if it is an object.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - BTNRep<K, V, NODE> | R
+     * @returns The function `isRaw` is checking if the `keyNodeEntryOrRaw` parameter is of type `R` by
+     * checking if it is an object. If the parameter is an object, the function will return `true`,
+     * indicating that it is of type `R`.
+     */
     isRaw(keyNodeEntryOrRaw) {
-        return typeof keyNodeEntryOrRaw === 'object';
+        return this._toEntryFn !== undefined && typeof keyNodeEntryOrRaw === 'object';
     }
     /**
      * The function `isRealNode` checks if a given input is a valid node in a binary tree.
@@ -281,6 +285,9 @@ export class BinaryTree extends IterableEntryBase {
     isNIL(keyNodeEntryOrRaw) {
         return keyNodeEntryOrRaw === this._NIL;
     }
+    isRange(keyNodeEntryRawOrPredicate) {
+        return keyNodeEntryRawOrPredicate instanceof Range;
+    }
     /**
      * The function determines whether a given key, node, entry, or raw data is a leaf node in a binary
      * tree.
@@ -436,6 +443,17 @@ export class BinaryTree extends IterableEntryBase {
         }
         return inserted;
     }
+    /**
+     * Time Complexity: O(k * n)
+     * Space Complexity: O(1)
+     *
+     * The `merge` function in TypeScript merges another binary tree into the current tree by adding all
+     * elements from the other tree.
+     * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
+     */
+    merge(anotherTree) {
+        this.addMany(anotherTree, []);
+    }
     /**
      * Time Complexity: O(k * n)
      * Space Complexity: O(1)
@@ -518,24 +536,27 @@ export class BinaryTree extends IterableEntryBase {
      * Time Complexity: O(n)
      * Space Complexity: O(k + log n)
      *
-     * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
-     * or predicate, with options for recursive or iterative traversal.
-     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
-     * - The `getNodes` function you provided takes several parameters:
-     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
-     * determines whether to return only the first node that matches the criteria specified by the
-     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
-     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
-     * `getNodes` function is used to specify the starting point for traversing the binary tree. It
-     * represents the root node of the binary tree or the node from which the traversal should begin. If
-     * not provided, the default value is set to `this._root
-     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
-     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
-     * can have two possible values:
-     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
-     * based on the input parameters and the iteration type specified.
+     * The `search` function in TypeScript performs a depth-first or breadth-first search on a tree
+     * structure based on a given predicate or key, with options to return multiple results or just one.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate - The
+     * `keyNodeEntryRawOrPredicate` parameter in the `search` function can accept three types of values:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `search` function is a boolean flag that
+     * determines whether the search should stop after finding the first matching node. If `onlyOne` is
+     * set to `true`, the search will return as soon as a matching node is found. If `onlyOne` is
+     * @param {C} callback - The `callback` parameter in the `search` function is a callback function
+     * that will be called on each node that matches the search criteria. It is of type `C`, which
+     * extends `NodeCallback<NODE>`. The default value for `callback` is `this._DEFAULT_NODE_CALLBACK` if
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the `search` function is
+     * used to specify the node from which the search operation should begin. It represents the starting
+     * point in the binary tree where the search will be performed. If no specific `startNode` is
+     * provided, the search operation will start from the root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `search` function
+     * specifies the type of iteration to be used when searching for nodes in a binary tree. It can have
+     * two possible values:
+     * @returns The `search` function returns an array of values that match the provided criteria based
+     * on the search algorithm implemented within the function.
      */
-    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+    search(keyNodeEntryRawOrPredicate, onlyOne = false, callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
         if (keyNodeEntryRawOrPredicate === undefined)
             return [];
         if (keyNodeEntryRawOrPredicate === null)
@@ -543,12 +564,12 @@ export class BinaryTree extends IterableEntryBase {
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return [];
-        const callback = this._ensurePredicate(keyNodeEntryRawOrPredicate);
+        const predicate = this._ensurePredicate(keyNodeEntryRawOrPredicate);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                if (callback(cur)) {
-                    ans.push(cur);
+                if (predicate(cur)) {
+                    ans.push(callback(cur));
                     if (onlyOne)
                         return;
                 }
@@ -566,8 +587,8 @@ export class BinaryTree extends IterableEntryBase {
             while (stack.length > 0) {
                 const cur = stack.pop();
                 if (this.isRealNode(cur)) {
-                    if (callback(cur)) {
-                        ans.push(cur);
+                    if (predicate(cur)) {
+                        ans.push(callback(cur));
                         if (onlyOne)
                             return ans;
                     }
@@ -580,6 +601,30 @@ export class BinaryTree extends IterableEntryBase {
         }
         return ans;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(k + log n)
+     *
+     * The function `getNodes` retrieves nodes from a binary tree based on a key, node, entry, raw data,
+     * or predicate, with options for recursive or iterative traversal.
+     * @param {BTNRep<K, V, NODE> | R | NodePredicate<NODE>} keyNodeEntryRawOrPredicate
+     * - The `getNodes` function you provided takes several parameters:
+     * @param [onlyOne=false] - The `onlyOne` parameter in the `getNodes` function is a boolean flag that
+     * determines whether to return only the first node that matches the criteria specified by the
+     * `keyNodeEntryRawOrPredicate` parameter. If `onlyOne` is set to `true`, the function will
+     * @param {BTNRep<K, V, NODE> | R} startNode - The `startNode` parameter in the
+     * `getNodes` function is used to specify the starting point for traversing the binary tree. It
+     * represents the root node of the binary tree or the node from which the traversal should begin. If
+     * not provided, the default value is set to `this._root
+     * @param {IterationType} iterationType - The `iterationType` parameter in the `getNodes` function
+     * determines the type of iteration to be performed when traversing the nodes of a binary tree. It
+     * can have two possible values:
+     * @returns The `getNodes` function returns an array of nodes that satisfy the provided condition
+     * based on the input parameters and the iteration type specified.
+     */
+    getNodes(keyNodeEntryRawOrPredicate, onlyOne = false, startNode = this._root, iterationType = this.iterationType) {
+        return this.search(keyNodeEntryRawOrPredicate, onlyOne, node => node, startNode, iterationType);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(log n).
@@ -601,23 +646,7 @@ export class BinaryTree extends IterableEntryBase {
      * or `null` if no matching node is found.
      */
     getNode(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType)[0] ?? null;
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(log n)
-     *
-     * The function `getNodeByKey` retrieves a node by its key from a binary tree structure.
-     * @param {K} key - The `key` parameter is the value used to search for a specific node in a data
-     * structure.
-     * @param {IterationType} iterationType - The `iterationType` parameter is a type of iteration that
-     * specifies how the tree nodes should be traversed when searching for a node with the given key. It
-     * is an optional parameter with a default value of `this.iterationType`.
-     * @returns The `getNodeByKey` function is returning an optional binary tree node
-     * (`OptNodeOrNull<NODE>`).
-     */
-    getNodeByKey(key, iterationType = this.iterationType) {
-        return this.getNode(key, this._root, iterationType);
+        return this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType)[0] ?? null;
     }
     /**
      * Time Complexity: O(n)
@@ -643,7 +672,7 @@ export class BinaryTree extends IterableEntryBase {
      */
     get(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
         if (this._isMapMode) {
-            const key = this._getKey(keyNodeEntryRawOrPredicate);
+            const key = this._extractKey(keyNodeEntryRawOrPredicate);
             if (key === null || key === undefined)
                 return;
             return this._store.get(key);
@@ -672,7 +701,7 @@ export class BinaryTree extends IterableEntryBase {
      * Otherwise, it returns `false`.
      */
     has(keyNodeEntryRawOrPredicate, startNode = this._root, iterationType = this.iterationType) {
-        return this.getNodes(keyNodeEntryRawOrPredicate, true, startNode, iterationType).length > 0;
+        return this.search(keyNodeEntryRawOrPredicate, true, node => node, startNode, iterationType).length > 0;
     }
     /**
      * Time Complexity: O(1)
@@ -931,7 +960,7 @@ export class BinaryTree extends IterableEntryBase {
      * array is either in reverse order or in the original order based on the value of the `isReverse`
      * parameter.
      */
-    getPathToRoot(callback = this._DEFAULT_NODE_CALLBACK, beginNode, isReverse = true) {
+    getPathToRoot(beginNode, callback = this._DEFAULT_NODE_CALLBACK, isReverse = false) {
         const result = [];
         let beginNodeEnsured = this.ensureNode(beginNode);
         if (!beginNodeEnsured)
@@ -1014,7 +1043,6 @@ export class BinaryTree extends IterableEntryBase {
     getRightMost(callback = this._DEFAULT_NODE_CALLBACK, startNode = this._root, iterationType = this.iterationType) {
         if (this.isNIL(startNode))
             return callback(undefined);
-        // TODO support get right most by passing key in
         startNode = this.ensureNode(startNode);
         if (!startNode)
             return callback(startNode);
@@ -1952,16 +1980,16 @@ export class BinaryTree extends IterableEntryBase {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_getKey` in TypeScript returns the key from a given input, which can be a node,
+     * The function `_extractKey` in TypeScript returns the key from a given input, which can be a node,
      * entry, raw data, or null/undefined.
-     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_getKey` method you provided is a
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `_extractKey` method you provided is a
      * TypeScript method that takes in a parameter `keyNodeEntryOrRaw` of type `BTNRep<K, V, NODE> | R`,
      * where `BTNRep` is a generic type with keys `K`, `V`, and `NODE`, and `
-     * @returns The `_getKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
+     * @returns The `_extractKey` method returns the key value extracted from the `keyNodeEntryOrRaw`
      * parameter. The return value can be a key value of type `K`, `null`, or `undefined`, depending on
      * the conditions checked in the method.
      */
-    _getKey(keyNodeEntryOrRaw) {
+    _extractKey(keyNodeEntryOrRaw) {
         if (keyNodeEntryOrRaw === null)
             return null;
         if (keyNodeEntryOrRaw === undefined)
@@ -2003,6 +2031,9 @@ export class BinaryTree extends IterableEntryBase {
         return this._store.set(key, value);
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearNodes function sets the root node to undefined and resets the size to 0.
      */
     _clearNodes() {
@@ -2010,6 +2041,9 @@ export class BinaryTree extends IterableEntryBase {
         this._size = 0;
     }
     /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
      * The _clearValues function clears all values stored in the _store object.
      */
     _clearValues() {