avl-tree-typed 1.48.1 → 1.48.2

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SinglyLinkedList = exports.SinglyLinkedListNode = void 0;
+const base_1 = require("../base");
 /**
  * data-structure-typed
  *
@@ -20,11 +21,12 @@ class SinglyLinkedListNode {
     }
 }
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
-class SinglyLinkedList {
+class SinglyLinkedList 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;
@@ -609,54 +611,31 @@ class SinglyLinkedList {
         return count;
     }
     /**
-     * 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 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) {
+     * 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, thisArg) {
         const filteredList = new SinglyLinkedList();
         let index = 0;
         for (const current of this) {
-            if (callback(current, index, this)) {
+            if (callback.call(thisArg, current, index, this)) {
                 filteredList.push(current);
             }
             index++;
@@ -668,21 +647,24 @@ class SinglyLinkedList {
      * 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(callback) {
+     * 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(callback, thisArg) {
         const mappedList = new SinglyLinkedList();
         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;
@@ -691,30 +673,15 @@ class SinglyLinkedList {
      * 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]);
     }
+    *_getIterator() {
+        let current = this.head;
+        while (current) {
+            yield current.value;
+            current = current.next;
+        }
+    }
 }
 exports.SinglyLinkedList = SinglyLinkedList;

package/dist/data-structures/queue/deque.d.ts

@@ -5,14 +5,15 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { IterableWithSizeOrLength } from "../../types";
+import { ElementCallback, IterableWithSizeOrLength } from "../../types";
+import { IterableElementBase } from "../base";
 /**
  * Deque can provide random access with O(1) time complexity
  * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
  * Deque may experience performance jitter, but DoublyLinkedList will not
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
-export declare class Deque<E> {
+export declare class Deque<E> extends IterableElementBase<E> {
     protected _bucketFirst: number;
     protected _firstInBucket: number;
     protected _bucketLast: number;
@@ -354,32 +355,6 @@ export declare class Deque<E> {
      * @returns The `toArray()` method is returning an array of elements of type `E`.
      */
     toArray(): E[];
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
-     * object to be iterated over using a for...of loop.
-     */
-    [Symbol.iterator](): Generator<E, void, unknown>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a deque and applies a callback function to
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * deque. It takes three parameters:
-     */
-    forEach(callback: (element: E, index: number, deque: this) => void): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -388,14 +363,19 @@ export declare class Deque<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new deque containing only the elements that satisfy the given
-     * predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
-     * `index`, and `deque`.
-     * @returns The `filter` method is returning a new `Deque` object that contains only the elements
-     * that satisfy the given `predicate` function.
+     * The `filter` function creates a new deque containing elements from the original deque that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the deque itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * deque or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Deque` object that contains the elements that
+     * satisfy the given predicate function.
      */
-    filter(predicate: (element: E, index: number, deque: this) => boolean): Deque<E>;
+    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -404,31 +384,29 @@ export declare class Deque<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the deque,
-     * returning a new deque with the results.
-     * @param callback - The `callback` parameter is a function that takes three arguments:
-     * @returns The `map` method is returning a new `Deque` object with the transformed elements.
+     * The `map` function creates a new Deque by applying a callback function to each element of the
+     * original Deque.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the deque. 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 a new Deque object with the mapped values.
      */
-    map<T>(callback: (element: E, index: number, deque: this) => T): Deque<T>;
+    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T>;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
+    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `reduce` function iterates over the elements of a deque and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The `callback` parameter is a function that takes four arguments:
-     * @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 deque.
-     * @returns the final value of the accumulator after iterating over all elements in the deque and
-     * applying the callback function to each element.
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
      */
-    reduce<T>(callback: (accumulator: T, element: E, index: number, deque: this) => T, initialValue: T): T;
-    print(): void;
+    protected _getIterator(): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

package/dist/data-structures/queue/deque.js

@@ -9,13 +9,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectDeque = exports.Deque = void 0;
 const utils_1 = require("../../utils");
+const base_1 = require("../base");
 /**
  * Deque can provide random access with O(1) time complexity
  * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
  * Deque may experience performance jitter, but DoublyLinkedList will not
  * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
  */
-class Deque {
+class Deque extends base_1.IterableElementBase {
     /**
      * The constructor initializes a data structure with a specified bucket size and populates it with
      * elements from an iterable.
@@ -26,6 +27,7 @@ class Deque {
      * stored in each bucket. It determines the size of each bucket in the data structure.
      */
     constructor(elements = [], bucketSize = (1 << 12)) {
+        super();
         this._bucketFirst = 0;
         this._firstInBucket = 0;
         this._bucketLast = 0;
@@ -651,42 +653,6 @@ class Deque {
         }
         return arr;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
-     * object to be iterated over using a for...of loop.
-     */
-    *[Symbol.iterator]() {
-        for (let i = 0; i < this.size; ++i) {
-            yield this.getAt(i);
-        }
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * The `forEach` function iterates over each element in a deque and applies a callback function to
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * deque. It takes three parameters:
-     */
-    forEach(callback) {
-        let index = 0;
-        for (const el of this) {
-            callback(el, index, this);
-            index++;
-        }
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -695,18 +661,23 @@ class Deque {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new deque containing only the elements that satisfy the given
-     * predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
-     * `index`, and `deque`.
-     * @returns The `filter` method is returning a new `Deque` object that contains only the elements
-     * that satisfy the given `predicate` function.
-     */
-    filter(predicate) {
+     * The `filter` function creates a new deque containing elements from the original deque that satisfy
+     * a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the deque itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * deque or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Deque` object that contains the elements that
+     * satisfy the given predicate function.
+     */
+    filter(predicate, thisArg) {
         const newDeque = new Deque([], this._bucketSize);
         let index = 0;
         for (const el of this) {
-            if (predicate(el, index, this)) {
+            if (predicate.call(thisArg, el, index, this)) {
                 newDeque.push(el);
             }
             index++;
@@ -721,48 +692,42 @@ class Deque {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `map` function takes a callback function and applies it to each element in the deque,
-     * returning a new deque with the results.
-     * @param callback - The `callback` parameter is a function that takes three arguments:
-     * @returns The `map` method is returning a new `Deque` object with the transformed elements.
+     * The `map` function creates a new Deque by applying a callback function to each element of the
+     * original Deque.
+     * @param callback - The `callback` parameter is a function that will be called for each element in
+     * the deque. 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 a new Deque object with the mapped values.
      */
-    map(callback) {
+    map(callback, thisArg) {
         const newDeque = new Deque([], this._bucketSize);
         let index = 0;
         for (const el of this) {
-            newDeque.push(callback(el, index, this));
+            newDeque.push(callback.call(thisArg, el, index, this));
             index++;
         }
         return newDeque;
     }
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
+    print() {
+        console.log([...this]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * The `reduce` function iterates over the elements of a deque and applies a callback function to
-     * each element, accumulating a single value.
-     * @param callback - The `callback` parameter is a function that takes four arguments:
-     * @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 deque.
-     * @returns the final value of the accumulator after iterating over all elements in the deque and
-     * applying the callback function to each element.
+     * The above function is an implementation of the iterator protocol in TypeScript, allowing the
+     * object to be iterated over using a for...of loop.
      */
-    reduce(callback, initialValue) {
-        let accumulator = initialValue;
-        let index = 0;
-        for (const el of this) {
-            accumulator = callback(accumulator, el, index, this);
-            index++;
+    *_getIterator() {
+        for (let i = 0; i < this.size; ++i) {
+            yield this.getAt(i);
         }
-        return accumulator;
-    }
-    print() {
-        console.log([...this]);
     }
     /**
      * Time Complexity: O(n)

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

@@ -4,29 +4,9 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
-export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
-    /**
-     * The enqueue function adds a value to the end of an array.
-     * @param {E} value - The value parameter represents the value that you want to add to the queue.
-     */
-    enqueue(value: E): void;
-    /**
-     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
-     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
-     */
-    dequeue(): E | undefined;
-    /**
-     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    getFirst(): E | undefined;
-    /**
-     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
-     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
-     */
-    peek(): E | undefined;
-}
-export declare class Queue<E = any> {
+import { IterableElementBase } from "../base";
+import { ElementCallback } from "../../types";
+export declare class Queue<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
@@ -206,21 +186,27 @@ export declare class Queue<E = any> {
      */
     clone(): Queue<E>;
     print(): void;
-    [Symbol.iterator](): Generator<E, void, unknown>;
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n)
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      *
-     * The `forEach` function iterates over each element in a deque and applies a callback function to
-     * each element.
-     * @param callback - The callback parameter is a function that will be called for each element in the
-     * deque. It takes three parameters:
-     */
-    forEach(callback: (element: E, index: number, queue: this) => void): void;
+     * The `filter` function creates a new `Queue` object containing elements from the original `Queue`
+     * that satisfy a given predicate function.
+     * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
+     * the current element being iterated over, the index of the current element, and the queue itself.
+     * It should return a boolean value indicating whether the element should be included in the filtered
+     * queue or not.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `Queue` object that contains the elements that
+     * satisfy the given predicate function.
+     */
+    filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Queue<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -229,27 +215,42 @@ export declare class Queue<E = any> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `filter` function creates a new deque containing only the elements that satisfy the given
-     * predicate function.
-     * @param predicate - The `predicate` parameter is a function that takes three arguments: `element`,
-     * `index`, and `deque`.
-     * @returns The `filter` method is returning a new `Queue` object that contains only the elements
-     * that satisfy the given `predicate` function.
+     * The `map` function takes a callback function and applies it to each element in the queue,
+     * returning a new queue with the results.
+     * @param callback - The callback parameter is a function that will be called for each element in the
+     * queue. It takes three arguments: the current element, the index of the current element, and the
+     * queue itself. The callback function should return a new value that will be added to the new queue.
+     * @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 `Queue` object with the transformed elements.
      */
-    filter(predicate: (element: E, index: number, queue: this) => boolean): Queue<E>;
+    map<T>(callback: ElementCallback<E, T>, thisArg?: any): Queue<T>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
+    protected _getIterator(): Generator<E, void, unknown>;
+}
+export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function takes a callback function and applies it to each element in the deque,
-     * returning a new deque with the results.
-     * @param callback - The `callback` parameter is a function that takes three arguments:
-     * @returns The `map` method is returning a new `Queue` object with the transformed elements.
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
-    map<T>(callback: (element: E, index: number, queue: this) => T): Queue<T>;
-    reduce<T>(callback: (accumulator: T, element: E, index: number, queue: this) => T, initialValue: T): T;
+    enqueue(value: E): void;
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
+     */
+    dequeue(): E | undefined;
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst(): E | undefined;
+    /**
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    peek(): E | undefined;
 }