linked-list-typed 1.48.1 → 1.48.2

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

@@ -6,8 +6,9 @@
  * @license MIT License
  */
 import type { BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNKey, BTNodeEntry, BTNodeExemplar, BTNodeKeyOrNode } from '../../types';
-import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout } from '../../types';
+import { BinaryTreeNested, BinaryTreePrintOptions, BiTreeDeleteResult, DFSOrderPattern, FamilyPosition, IterationType, NodeDisplayLayout, PairCallback } from '../../types';
 import { IBinaryTree } from '../../interfaces';
+import { IterablePairBase } from "../base";
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -41,7 +42,7 @@ export declare class BinaryTreeNode<V = any, N extends BinaryTreeNode<V, N> = Bi
  * 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 declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> implements IBinaryTree<V, N, TREE> {
+export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode<V, BinaryTreeNodeNested<V>>, TREE extends BinaryTree<V, N, TREE> = BinaryTree<V, N, BinaryTreeNested<V, N>>> extends IterablePairBase<BTNKey, V | undefined> implements IBinaryTree<V, N, TREE> {
     iterationType: IterationType;
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
@@ -460,31 +461,6 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>): ReturnType<C>[];
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "keys" returns an array of keys from a given object.
-     * @returns an array of BTNKey objects.
-     */
-    keys(): BTNKey[];
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "values" returns an array of values from a map-like object.
-     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
-     * object.
-     */
-    values(): (V | undefined)[];
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -499,55 +475,45 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      */
     clone(): TREE;
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
+     * Time Complexity: O(n)
+     * 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: (entry: [BTNKey, V | undefined], tree: this) => void): void;
+     * 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: PairCallback<BTNKey, V | undefined, boolean>, thisArg?: any): TREE;
     /**
-     * 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: (entry: [BTNKey, V | undefined], tree: this) => boolean): TREE;
     /**
-     * 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)
+     *
+     * 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: (entry: [BTNKey, V | undefined], tree: this) => V): TREE;
-    /**
-     * 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<T>(callback: (accumulator: T, entry: [BTNKey, V | undefined], tree: this) => T, initialValue: T): T;
-    /**
-     * 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?: N | null | undefined): Generator<[BTNKey, V | undefined], void, undefined>;
+    map(callback: PairCallback<BTNKey, V | undefined, V>, thisArg?: any): TREE;
     /**
      * 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 |
@@ -556,6 +522,7 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
      */
     print(beginRoot?: BTNodeKeyOrNode<N>, options?: BinaryTreePrintOptions): void;
+    protected _getIterator(node?: N | null | undefined): IterableIterator<[BTNKey, V | undefined]>;
     protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
     protected _defaultOneParamCallback: (node: N) => number;
     /**

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

@@ -11,6 +11,7 @@ exports.BinaryTree = exports.BinaryTreeNode = void 0;
 const types_1 = require("../../types");
 const utils_1 = require("../../utils");
 const queue_1 = require("../queue");
+const base_1 = require("../base");
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
@@ -69,7 +70,7 @@ exports.BinaryTreeNode = 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.
  */
-class BinaryTree {
+class BinaryTree extends base_1.IterablePairBase {
     /**
      * The constructor function initializes a binary tree object with optional elements and options.
      * @param [elements] - An optional iterable of BTNodeExemplar objects. These objects represent the
@@ -80,6 +81,7 @@ class BinaryTree {
      * required.
      */
     constructor(elements, options) {
+        super();
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._defaultOneParamCallback = (node) => node.key;
         if (options) {
@@ -1404,43 +1406,6 @@ class BinaryTree {
         }
         return ans;
     }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "keys" returns an array of keys from a given object.
-     * @returns an array of BTNKey objects.
-     */
-    keys() {
-        const keys = [];
-        for (const entry of this) {
-            keys.push(entry[0]);
-        }
-        return keys;
-    }
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     */
-    /**
-     * Time complexity: O(n)
-     * Space complexity: O(n)
-     *
-     * The function "values" returns an array of values from a map-like object.
-     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
-     * object.
-     */
-    values() {
-        const values = [];
-        for (const entry of this) {
-            values.push(entry[1]);
-        }
-        return values;
-    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -1459,114 +1424,70 @@ class BinaryTree {
         return cloned;
     }
     /**
-     * Time complexity: O(n)
-     * Space complexity: O(1)
-     */
-    /**
-     * 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.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      */
-    forEach(callback) {
-        for (const entry of this) {
-            callback(entry, this);
-        }
-    }
     /**
-     * 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.
-     */
-    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 === types_1.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 |
@@ -1596,6 +1517,34 @@ class BinaryTree {
         };
         display(beginRoot);
     }
+    *_getIterator(node = this.root) {
+        if (!node)
+            return;
+        if (this.iterationType === types_1.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/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/data-structures/graph/abstract-graph.js

@@ -11,6 +11,7 @@ exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 const utils_1 = require("../../utils");
 const priority_queue_1 = require("../priority-queue");
 const queue_1 = require("../queue");
+const base_1 = require("../base");
 class AbstractVertex {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -45,8 +46,9 @@ class AbstractEdge {
     }
 }
 exports.AbstractEdge = AbstractEdge;
-class AbstractGraph {
+class AbstractGraph extends base_1.IterablePairBase {
     constructor() {
+        super();
         this._vertices = new Map();
     }
     get vertices() {
@@ -1028,46 +1030,67 @@ 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)) {