data-structure-typed 1.48.0 → 1.48.2

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

@@ -8,6 +8,7 @@
 import { FamilyPosition, IterationType } from '../../types';
 import { trampoline } from '../../utils';
 import { Queue } from '../queue';
+import { IterablePairBase } from "../base";
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -70,7 +71,7 @@ export class BinaryTreeNode {
  * 8. Full Trees: Every node has either 0 or 2 children.
  * 9. Complete Trees: All levels are fully filled except possibly the last, filled from left to right.
  */
-export class BinaryTree {
+export class BinaryTree extends IterablePairBase {
     iterationType = IterationType.ITERATIVE;
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
@@ -82,6 +83,7 @@ export class BinaryTree {
      * required.
      */
     constructor(elements, options) {
+        super();
         if (options) {
             const { iterationType } = options;
             if (iterationType) {
@@ -1405,113 +1407,86 @@ export class BinaryTree {
     }
     /**
      * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Space complexity: O(n)
      */
     /**
-     * The `forEach` function iterates over each entry in a tree and calls a callback function with the
-     * entry and the tree as arguments.
-     * @param callback - The callback parameter is a function that will be called for each entry in the
-     * tree. It takes two parameters: entry and tree.
-     */
-    forEach(callback) {
-        for (const entry of this) {
-            callback(entry, this);
-        }
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
+     * the new tree.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this.bfs(node => cloned.add([node.key, node.value]));
+        return cloned;
     }
     /**
-     * The `filter` function creates a new tree by iterating over the entries of the current tree and
-     * adding the entries that satisfy the given predicate.
-     * @param predicate - The `predicate` parameter is a function that takes two arguments: `entry` and
-     * `tree`.
-     * @returns The `filter` method is returning a new tree object that contains only the entries that
-     * satisfy the given predicate function.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    filter(predicate) {
+    /**
+     * 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.
+     * @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.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
+     * it will be passed as the first argument to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new tree object that contains the key-value pairs that
+     * pass the given predicate function.
+     */
+    filter(predicate, thisArg) {
         const newTree = this.createTree();
+        let index = 0;
         for (const [key, value] of this) {
-            if (predicate([key, value], this)) {
+            if (predicate.call(thisArg, value, key, index++, this)) {
                 newTree.add([key, value]);
             }
         }
         return newTree;
     }
     /**
-     * The `map` function creates a new tree by applying a callback function to each entry in the current
-     * tree.
-     * @param callback - The callback parameter is a function that takes two arguments: entry and tree.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new tree by applying a callback function to each key-value pair in
+     * the original tree.
+     * @param callback - The callback parameter is a function that will be called for each key-value pair
+     * in the tree. It takes four arguments: the value of the current pair, the key of the current pair,
+     * the index of the current pair, and a reference to the tree itself. The callback function should
+     * return a new
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If you pass a value for `thisArg`, it
+     * will be used as the `this` value when the callback function is called. If you don't pass a value
      * @returns The `map` method is returning a new tree object.
      */
-    map(callback) {
+    map(callback, thisArg) {
         const newTree = this.createTree();
+        let index = 0;
         for (const [key, value] of this) {
-            newTree.add([key, callback([key, value], this)]);
+            newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
         }
         return newTree;
     }
-    // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-    // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
-    //   const newTree = this.createTree();
-    //   for (const [key, value] of this) {
-    //     newTree.add(key, callback([key, value], this));
-    //   }
-    //   return newTree;
-    // }
-    /**
-     * The `reduce` function iterates over the entries of a tree and applies a callback function to each
-     * entry, accumulating a single value.
-     * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * entry, and tree. It is called for each entry in the tree and is used to accumulate a single value
-     * based on the logic defined in the callback function.
-     * @param {T} initialValue - The initialValue parameter is the initial value of the accumulator. It
-     * is the value that will be passed as the first argument to the callback function when reducing the
-     * elements of the tree.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-     * all the entries in the tree and applying the callback function to each entry.
-     */
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        for (const [key, value] of this) {
-            accumulator = callback(accumulator, [key, value], this);
-        }
-        return accumulator;
-    }
-    /**
-     * The above function is an iterator for a binary tree that can be used to traverse the tree in
-     * either an iterative or recursive manner.
-     * @param node - The `node` parameter represents the current node in the binary tree from which the
-     * iteration starts. It is an optional parameter with a default value of `this.root`, which means
-     * that if no node is provided, the iteration will start from the root of the binary tree.
-     * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
-     * binary tree nodes in a specific order.
-     */
-    *[Symbol.iterator](node = this.root) {
-        if (!node)
-            return;
-        if (this.iterationType === IterationType.ITERATIVE) {
-            const stack = [];
-            let current = node;
-            while (current || stack.length > 0) {
-                while (current && !isNaN(current.key)) {
-                    stack.push(current);
-                    current = current.left;
-                }
-                current = stack.pop();
-                if (current && !isNaN(current.key)) {
-                    yield [current.key, current.value];
-                    current = current.right;
-                }
-            }
-        }
-        else {
-            if (node.left && !isNaN(node.key)) {
-                yield* this[Symbol.iterator](node.left);
-            }
-            yield [node.key, node.value];
-            if (node.right && !isNaN(node.key)) {
-                yield* this[Symbol.iterator](node.right);
-            }
-        }
-    }
+    // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
+    // // map<NV>(callback: (entry: [BTNKey, V | undefined], tree: this) => NV) {
+    // //   const newTree = this.createTree();
+    // //   for (const [key, value] of this) {
+    // //     newTree.add(key, callback([key, value], this));
+    // //   }
+    // //   return newTree;
+    // // }
+    //
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
      * @param {BTNKey | N | null | undefined} [beginRoot=this.root] - The `root` parameter is of type `BTNKey | N | null |
@@ -1541,6 +1516,34 @@ export class BinaryTree {
         };
         display(beginRoot);
     }
+    *_getIterator(node = this.root) {
+        if (!node)
+            return;
+        if (this.iterationType === IterationType.ITERATIVE) {
+            const stack = [];
+            let current = node;
+            while (current || stack.length > 0) {
+                while (current && !isNaN(current.key)) {
+                    stack.push(current);
+                    current = current.left;
+                }
+                current = stack.pop();
+                if (current && !isNaN(current.key)) {
+                    yield [current.key, current.value];
+                    current = current.right;
+                }
+            }
+        }
+        else {
+            if (node.left && !isNaN(node.key)) {
+                yield* this[Symbol.iterator](node.left);
+            }
+            yield [node.key, node.value];
+            if (node.right && !isNaN(node.key)) {
+                yield* this[Symbol.iterator](node.right);
+            }
+        }
+    }
     _displayAux(node, options) {
         const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
         const emptyDisplayLayout = [['─'], 1, 0, 0];

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

@@ -137,6 +137,18 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone(): TREE;
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.

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

@@ -279,6 +279,22 @@ export class TreeMultimap extends AVLTree {
         super.clear();
         this._count = 0;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+        const cloned = this.createTree();
+        this.bfs(node => cloned.add([node.key, node.value], node.count));
+        return cloned;
+    }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.

package/dist/mjs/data-structures/graph/abstract-graph.d.ts

@@ -1,5 +1,7 @@
 import type { DijkstraResult, VertexKey } from '../../types';
+import { PairCallback } from "../../types";
 import { IGraph } from '../../interfaces';
+import { IterablePairBase } from "../base";
 export declare abstract class AbstractVertex<V = any> {
     key: VertexKey;
     value: V | undefined;
@@ -28,7 +30,8 @@ export declare abstract class AbstractEdge<E = any> {
     protected _hashCode: string;
     get hashCode(): string;
 }
-export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> implements IGraph<V, E, VO, EO> {
+export declare abstract class AbstractGraph<V = any, E = any, VO extends AbstractVertex<V> = AbstractVertex<V>, EO extends AbstractEdge<E> = AbstractEdge<E>> extends IterablePairBase<VertexKey, V | undefined> implements IGraph<V, E, VO, EO> {
+    constructor();
     protected _vertices: Map<VertexKey, VO>;
     get vertices(): Map<VertexKey, VO>;
     /**
@@ -443,11 +446,46 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns the bridges found using the Tarjan algorithm.
      */
     getBridges(): EO[];
-    [Symbol.iterator](): Iterator<[VertexKey, V | undefined]>;
-    forEach(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => void): void;
-    filter(predicate: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => boolean): [VertexKey, V | undefined][];
-    map<T>(callback: (entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T): T[];
-    reduce<T>(callback: (accumulator: T, entry: [VertexKey, V | undefined], index: number, map: Map<VertexKey, VO>) => T, initialValue: T): T;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function iterates over key-value pairs in a data structure and returns an array of
+     * pairs that satisfy a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It is used to determine whether an element should be included
+     * in the filtered array. The callback function should return `true` if the element should be
+     * included, and `
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method returns an array of key-value pairs `[VertexKey, V | undefined][]`
+     * that satisfy the given predicate function.
+     */
+    filter(predicate: PairCallback<VertexKey, V | undefined, boolean>, thisArg?: any): [VertexKey, V | undefined][];
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function iterates over the elements of a collection and applies a callback function to
+     * each element, returning an array of the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * map. It takes four arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
+     * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
+     * @returns The `map` function is returning an array of type `T[]`.
+     */
+    map<T>(callback: PairCallback<VertexKey, V | undefined, T>, thisArg?: any): T[];
+    protected _getIterator(): IterableIterator<[VertexKey, V | undefined]>;
     protected abstract _addEdgeOnly(edge: EO): boolean;
     protected _addVertexOnly(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;

package/dist/mjs/data-structures/graph/abstract-graph.js

@@ -8,6 +8,7 @@
 import { uuidV4 } from '../../utils';
 import { PriorityQueue } from '../priority-queue';
 import { Queue } from '../queue';
+import { IterablePairBase } from "../base";
 export class AbstractVertex {
     key;
     value;
@@ -45,7 +46,10 @@ export class AbstractEdge {
         return this._hashCode;
     }
 }
-export class AbstractGraph {
+export class AbstractGraph extends IterablePairBase {
+    constructor() {
+        super();
+    }
     _vertices = new Map();
     get vertices() {
         return this._vertices;
@@ -1021,46 +1025,67 @@ export class AbstractGraph {
     getBridges() {
         return this.tarjan(false, true, false, false).bridges;
     }
-    *[Symbol.iterator]() {
-        for (const vertex of this._vertices.values()) {
-            yield [vertex.key, vertex.value];
-        }
-    }
-    forEach(callback) {
-        let index = 0;
-        for (const vertex of this) {
-            callback(vertex, index, this._vertices);
-            index++;
-        }
-    }
-    filter(predicate) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function iterates over key-value pairs in a data structure and returns an array of
+     * pairs that satisfy a given predicate.
+     * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+     * `value`, `key`, `index`, and `this`. It is used to determine whether an element should be included
+     * in the filtered array. The callback function should return `true` if the element should be
+     * included, and `
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+     * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
+     * @returns The `filter` method returns an array of key-value pairs `[VertexKey, V | undefined][]`
+     * that satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
         const filtered = [];
         let index = 0;
-        for (const entry of this) {
-            if (predicate(entry, index, this._vertices)) {
-                filtered.push(entry);
+        for (const [key, value] of this) {
+            if (predicate.call(thisArg, value, key, index, this)) {
+                filtered.push([key, value]);
             }
             index++;
         }
         return filtered;
     }
-    map(callback) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function iterates over the elements of a collection and applies a callback function to
+     * each element, returning an array of the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * map. It takes four arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
+     * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
+     * @returns The `map` function is returning an array of type `T[]`.
+     */
+    map(callback, thisArg) {
         const mapped = [];
         let index = 0;
-        for (const entry of this) {
-            mapped.push(callback(entry, index, this._vertices));
+        for (const [key, value] of this) {
+            mapped.push(callback.call(thisArg, value, key, index, this));
             index++;
         }
         return mapped;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const entry of this) {
-            accumulator = callback(accumulator, entry, index, this._vertices);
-            index++;
+    *_getIterator() {
+        for (const vertex of this._vertices.values()) {
+            yield [vertex.key, vertex.value];
         }
-        return accumulator;
     }
     _addVertexOnly(newVertex) {
         if (this.hasVertex(newVertex)) {