undirected-graph-typed 1.48.1 → 1.48.2

package/dist/data-structures/heap/heap.js

@@ -7,8 +7,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FibonacciHeap = exports.FibonacciHeapNode = exports.Heap = void 0;
-class Heap {
+const base_1 = require("../base");
+class Heap extends base_1.IterableElementBase {
     constructor(elements, options) {
+        super();
         this._elements = [];
         const defaultComparator = (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
@@ -310,47 +312,70 @@ class Heap {
         for (let i = Math.floor(this.size / 2); i >= 0; i--)
             this._sinkDown(i, this.elements.length >> 1);
     }
-    *[Symbol.iterator]() {
-        for (const element of this.elements) {
-            yield element;
-        }
-    }
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
-    filter(predicate) {
-        const filteredHeap = new Heap([], this.options);
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `filter` function creates a new Heap object containing elements that pass a given callback
+     * function.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the heap. It takes three arguments: the current element, the index of the current element, and the
+     * heap itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+     * the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
+        const filteredList = new Heap();
         let index = 0;
-        for (const el of this) {
-            if (predicate(el, index, this)) {
-                filteredHeap.push(el);
+        for (const current of this) {
+            if (callback.call(thisArg, current, index, this)) {
+                filteredList.push(current);
             }
             index++;
         }
-        return filteredHeap;
+        return filteredList;
     }
-    map(callback, comparator) {
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `map` function creates a new heap by applying a callback function to each element of the
+     * original heap.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * original heap. It takes three arguments: the current element, the index of the current element,
+     * and the original heap itself. The callback function should return a value of type T, which will be
+     * added to the mapped heap.
+     * @param comparator - The `comparator` parameter is a function that is used to compare elements in
+     * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
+     * `b`, a positive number if `a` is greater than `b`, or
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+     * specify the value of `this` within the callback function. It is used when you want to bind a
+     * specific object as the context for the callback function. If `thisArg` is not provided,
+     * `undefined` is used as
+     * @returns a new instance of the Heap class, which is created using the mapped elements from the
+     * original Heap.
+     */
+    map(callback, comparator, thisArg) {
         const mappedHeap = new Heap([], { comparator: comparator });
         let index = 0;
         for (const el of this) {
-            mappedHeap.add(callback(el, index, this));
+            mappedHeap.add(callback.call(thisArg, el, index, this));
             index++;
         }
         return mappedHeap;
     }
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const el of this) {
-            accumulator = callback(accumulator, el, index, this);
-            index++;
-        }
-        return accumulator;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -358,6 +383,11 @@ class Heap {
     print() {
         console.log([...this]);
     }
+    *_getIterator() {
+        for (const element of this.elements) {
+            yield element;
+        }
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)

package/dist/data-structures/index.d.ts

@@ -9,3 +9,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './base';

package/dist/data-structures/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);
 __exportStar(require("./trie"), exports);
+__exportStar(require("./base"), exports);

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -1,3 +1,5 @@
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
 /**
  * data-structure-typed
  *
@@ -16,7 +18,7 @@ export declare class DoublyLinkedListNode<E = any> {
      */
     constructor(value: E);
 }
-export declare class DoublyLinkedList<E = any> {
+export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
@@ -387,71 +389,56 @@ export declare class DoublyLinkedList<E = any> {
      */
     toReversedArray(): E[];
     /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    [Symbol.iterator](): Generator<E, void, unknown>;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
-     */
-    forEach(callback: (value: E, index: number, list: DoublyLinkedList<E>) => void): void;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
-     */
-    filter(callback: (value: E, index: number, list: DoublyLinkedList<E>) => boolean): DoublyLinkedList<E>;
+     * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
+     * list and applying a callback function to each element, returning only the elements for which the
+     * callback function returns true.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the DoublyLinkedList. It takes three arguments: the current element, the index of the current
+     * element, and the DoublyLinkedList itself. The callback function should return a boolean value
+     * indicating whether the current element should be included
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
+     * elements that pass the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, boolean>, thisArg?: any): DoublyLinkedList<E>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
-     */
-    map<T>(callback: (value: E, index: number, list: DoublyLinkedList<E>) => T): DoublyLinkedList<T>;
+     * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
+     * in the original list.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
+     * and the DoublyLinkedList itself. The callback function should return a value that will be added to
+     * the new DoublyLinkedList that
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `DoublyLinkedList` object that contains the results
+     * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
+     * object.
+     */
+    map<T>(callback: ElementCallback<E, T>, thisArg?: any): DoublyLinkedList<T>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-     * single value.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
-     * used to perform a specific operation on each element of the linked list.
-     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-     * point for the reduction operation.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-     * elements in the linked list.
-     */
-    reduce<T>(callback: (accumulator: T, value: E, index: number, list: DoublyLinkedList<E>) => T, initialValue: T): T;
     print(): void;
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    protected _getIterator(): IterableIterator<E>;
 }

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
+const base_1 = require("../base");
 /**
  * data-structure-typed
  *
@@ -21,11 +22,12 @@ class DoublyLinkedListNode {
     }
 }
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
-class DoublyLinkedList {
+class DoublyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
     constructor(elements) {
+        super();
         this._head = undefined;
         this._tail = undefined;
         this._length = 0;
@@ -667,54 +669,31 @@ class DoublyLinkedList {
         return array;
     }
     /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    *[Symbol.iterator]() {
-        let current = this.head;
-        while (current) {
-            yield current.value;
-            current = current.next;
-        }
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
-     */
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
-     */
-    filter(callback) {
+     * The `filter` function creates a new DoublyLinkedList by iterating over the elements of the current
+     * list and applying a callback function to each element, returning only the elements for which the
+     * callback function returns true.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the DoublyLinkedList. It takes three arguments: the current element, the index of the current
+     * element, and the DoublyLinkedList itself. The callback function should return a boolean value
+     * indicating whether the current element should be included
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
+     * elements that pass the filter condition specified by the `callback` function.
+     */
+    filter(callback, thisArg) {
         const filteredList = new DoublyLinkedList();
         let index = 0;
         for (const current of this) {
-            if (callback(current, index, this)) {
+            if (callback.call(thisArg, current, index, this)) {
                 filteredList.push(current);
             }
             index++;
@@ -726,21 +705,27 @@ class DoublyLinkedList {
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
-     * DoublyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original DoublyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
-     * DoublyLinkedList).
-     * @returns The `map` function is returning a new instance of `DoublyLinkedList<T>` that contains the mapped values.
-     */
-    map(callback) {
+     * The `map` function creates a new DoublyLinkedList by applying a callback function to each element
+     * in the original list.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * DoublyLinkedList. It takes three arguments: the current element, the index of the current element,
+     * and the DoublyLinkedList itself. The callback function should return a value that will be added to
+     * the new DoublyLinkedList that
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `DoublyLinkedList` object that contains the results
+     * of applying the provided `callback` function to each element in the original `DoublyLinkedList`
+     * object.
+     */
+    map(callback, thisArg) {
         const mappedList = new DoublyLinkedList();
         let index = 0;
         for (const current of this) {
-            mappedList.push(callback(current, index, this));
+            mappedList.push(callback.call(thisArg, current, index, this));
             index++;
         }
         return mappedList;
@@ -749,30 +734,18 @@ class DoublyLinkedList {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-     * single value.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
-     * used to perform a specific operation on each element of the linked list.
-     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-     * point for the reduction operation.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-     * elements in the linked list.
-     */
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const current of this) {
-            accumulator = callback(accumulator, current, index, this);
-            index++;
-        }
-        return accumulator;
-    }
     print() {
         console.log([...this]);
     }
+    /**
+     * The function returns an iterator that iterates over the values of a linked list.
+     */
+    *_getIterator() {
+        let current = this.head;
+        while (current) {
+            yield current.value;
+            current = current.next;
+        }
+    }
 }
 exports.DoublyLinkedList = DoublyLinkedList;

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,3 +1,5 @@
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
 /**
  * data-structure-typed
  *
@@ -15,7 +17,7 @@ export declare class SinglyLinkedListNode<E = any> {
      */
     constructor(value: E);
 }
-export declare class SinglyLinkedList<E = any> {
+export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
@@ -345,71 +347,50 @@ export declare class SinglyLinkedList<E = any> {
      */
     countOccurrences(value: E): number;
     /**
-     * The function returns an iterator that iterates over the values of a linked list.
-     */
-    [Symbol.iterator](): Generator<E, void, unknown>;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
-     * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
-     * represents the value of the current node in the linked list, and the index argument represents the index of the
-     * current node in the linked list.
-     */
-    forEach(callback: (value: E, index: number, list: SinglyLinkedList<E>) => void): void;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
-     * elements that satisfy the given callback function.
-     * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
-     * It is used to determine whether a value should be included in the filtered list or not.
-     * @returns The filtered list, which is an instance of the SinglyLinkedList class.
-     */
-    filter(callback: (value: E, index: number, list: SinglyLinkedList<E>) => boolean): SinglyLinkedList<E>;
+     * The `filter` function creates a new SinglyLinkedList by iterating over the elements of the current
+     * list and applying a callback function to each element to determine if it should be included in the
+     * filtered list.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * list. It takes three arguments: the current element, the index of the current element, and the
+     * list itself. The callback function should return a boolean value indicating whether the current
+     * element should be included in the filtered list or not
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `SinglyLinkedList` object that contains the
+     * elements that pass the filter condition specified by the `callback` function.
+     */
+    filter(callback: ElementCallback<E, boolean>, thisArg?: any): SinglyLinkedList<E>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
-     * SinglyLinkedList with the transformed values.
-     * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
-     * the original SinglyLinkedList) and returns a value of type T (the type of values that will be stored in the mapped
-     * SinglyLinkedList).
-     * @returns The `map` function is returning a new instance of `SinglyLinkedList<T>` that contains the mapped values.
-     */
-    map<T>(callback: (value: E, index: number, list: SinglyLinkedList<E>) => T): SinglyLinkedList<T>;
+     * The `map` function creates a new SinglyLinkedList by applying a callback function to each element
+     * of the original list.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the linked list. It takes three arguments:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `callback` function. If `thisArg` is
+     * @returns The `map` function is returning a new `SinglyLinkedList` object that contains the results
+     * of applying the provided `callback` function to each element in the original list.
+     */
+    map<T>(callback: ElementCallback<E, T>, thisArg?: any): SinglyLinkedList<T>;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(n)
      */
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     *
-     * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
-     * single value.
-     * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is
-     * used to perform a specific operation on each element of the linked list.
-     * @param {T} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
-     * point for the reduction operation.
-     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
-     * elements in the linked list.
-     */
-    reduce<T>(callback: (accumulator: T, value: E, index: number, list: SinglyLinkedList<E>) => T, initialValue: T): T;
     print(): void;
+    protected _getIterator(): IterableIterator<E>;
 }