undirected-graph-typed 1.54.3 → 2.0.1

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

@@ -14,8 +14,129 @@ import { IterableElementBase } from '../base';
  * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
  * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
  * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
  */
-export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E, R>> {
+export declare class Stack<E = any, R = any> extends IterableElementBase<E, R> {
     constructor(elements?: Iterable<E> | Iterable<R>, options?: StackOptions<E, R>);
     protected _elements: E[];
     /**
@@ -102,14 +223,6 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * @returns An array of type E.
      */
     deleteAt(index: number): boolean;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray(): E[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -141,7 +254,7 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * @returns The `filter` method is returning a new `Stack` object that contains the elements that
      * satisfy the given predicate function.
      */
-    filter(predicate: ElementCallback<E, R, boolean, Stack<E, R>>, thisArg?: any): Stack<E, R>;
+    filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Stack<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -159,7 +272,7 @@ export declare class Stack<E = any, R = any> extends IterableElementBase<E, R, S
      * value of
      * @returns a new Stack object with elements of type EM and raw elements of type RM.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, Stack<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Stack<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Stack<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)

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

@@ -9,6 +9,127 @@ const base_1 = require("../base");
  * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
  * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
  * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
+ * @example
+ * // Balanced Parentheses or Brackets
+ *     type ValidCharacters = ')' | '(' | ']' | '[' | '}' | '{';
+ *
+ *     const stack = new Stack<string>();
+ *     const input: ValidCharacters[] = '[({})]'.split('') as ValidCharacters[];
+ *     const matches: { [key in ValidCharacters]?: ValidCharacters } = { ')': '(', ']': '[', '}': '{' };
+ *     for (const char of input) {
+ *       if ('([{'.includes(char)) {
+ *         stack.push(char);
+ *       } else if (')]}'.includes(char)) {
+ *         if (stack.pop() !== matches[char]) {
+ *           fail('Parentheses are not balanced');
+ *         }
+ *       }
+ *     }
+ *     console.log(stack.isEmpty()); // true
+ * @example
+ * // Expression Evaluation and Conversion
+ *     const stack = new Stack<number>();
+ *     const expression = [5, 3, '+']; // Equivalent to 5 + 3
+ *     expression.forEach(token => {
+ *       if (typeof token === 'number') {
+ *         stack.push(token);
+ *       } else {
+ *         const b = stack.pop()!;
+ *         const a = stack.pop()!;
+ *         stack.push(token === '+' ? a + b : 0); // Only handling '+' here
+ *       }
+ *     });
+ *     console.log(stack.pop()); // 8
+ * @example
+ * // Depth-First Search (DFS)
+ *     const stack = new Stack<number>();
+ *     const graph: { [key in number]: number[] } = { 1: [2, 3], 2: [4], 3: [5], 4: [], 5: [] };
+ *     const visited: number[] = [];
+ *     stack.push(1);
+ *     while (!stack.isEmpty()) {
+ *       const node = stack.pop()!;
+ *       if (!visited.includes(node)) {
+ *         visited.push(node);
+ *         graph[node].forEach(neighbor => stack.push(neighbor));
+ *       }
+ *     }
+ *     console.log(visited); // [1, 3, 5, 2, 4]
+ * @example
+ * // Backtracking Algorithms
+ *     const stack = new Stack<[number, number]>();
+ *     const maze = [
+ *       ['S', ' ', 'X'],
+ *       ['X', ' ', 'X'],
+ *       [' ', ' ', 'E']
+ *     ];
+ *     const start: [number, number] = [0, 0];
+ *     const end = [2, 2];
+ *     const directions = [
+ *       [0, 1], // To the right
+ *       [1, 0], // down
+ *       [0, -1], // left
+ *       [-1, 0] // up
+ *     ];
+ *
+ *     const visited = new Set<string>(); // Used to record visited nodes
+ *     stack.push(start);
+ *     const path: number[][] = [];
+ *
+ *     while (!stack.isEmpty()) {
+ *       const [x, y] = stack.pop()!;
+ *       if (visited.has(`${x},${y}`)) continue; // Skip already visited nodes
+ *       visited.add(`${x},${y}`);
+ *
+ *       path.push([x, y]);
+ *
+ *       if (x === end[0] && y === end[1]) {
+ *         break; // Find the end point and exit
+ *       }
+ *
+ *       for (const [dx, dy] of directions) {
+ *         const nx = x + dx;
+ *         const ny = y + dy;
+ *         if (
+ *           maze[nx]?.[ny] === ' ' || // feasible path
+ *           maze[nx]?.[ny] === 'E' // destination
+ *         ) {
+ *           stack.push([nx, ny]);
+ *         }
+ *       }
+ *     }
+ *
+ *     expect(path).toContainEqual(end);
+ * @example
+ * // Function Call Stack
+ *     const functionStack = new Stack<string>();
+ *     functionStack.push('main');
+ *     functionStack.push('foo');
+ *     functionStack.push('bar');
+ *     console.log(functionStack.pop()); // 'bar'
+ *     console.log(functionStack.pop()); // 'foo'
+ *     console.log(functionStack.pop()); // 'main'
+ * @example
+ * // Simplify File Paths
+ *     const stack = new Stack<string>();
+ *     const path = '/a/./b/../../c';
+ *     path.split('/').forEach(segment => {
+ *       if (segment === '..') stack.pop();
+ *       else if (segment && segment !== '.') stack.push(segment);
+ *     });
+ *     console.log(stack.elements.join('/')); // 'c'
+ * @example
+ * // Stock Span Problem
+ *     const stack = new Stack<number>();
+ *     const prices = [100, 80, 60, 70, 60, 75, 85];
+ *     const spans: number[] = [];
+ *     prices.forEach((price, i) => {
+ *       while (!stack.isEmpty() && prices[stack.peek()!] <= price) {
+ *         stack.pop();
+ *       }
+ *       spans.push(stack.isEmpty() ? i + 1 : i - stack.peek()!);
+ *       stack.push(i);
+ *     });
+ *     console.log(spans); // [1, 1, 1, 2, 1, 4, 6]
  */
 class Stack extends base_1.IterableElementBase {
     constructor(elements = [], options) {
@@ -136,16 +257,6 @@ class Stack extends base_1.IterableElementBase {
         const spliced = this.elements.splice(index, 1);
         return spliced.length === 1;
     }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray() {
-        return this.elements.slice();
-    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -143,7 +143,7 @@ export declare class TrieNode {
  *     const subnet = ip.split('.').slice(0, 3).join('.');
  *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
-export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
+export declare class Trie<R = any> extends IterableElementBase<string, R> {
     /**
      * The constructor initializes a Trie data structure with optional options and words provided as
      * input.
@@ -311,7 +311,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * specific object as the context for the `predicate` function. If `thisArg` is provided, it will be
      * @returns The `filter` method is returning an array of strings (`string[]`).
      */
-    filter(predicate: ElementCallback<string, R, boolean, Trie<R>>, thisArg?: any): Trie<R>;
+    filter(predicate: ElementCallback<string, R, boolean>, thisArg?: any): Trie<R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -330,7 +330,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * value of
      * @returns a new Trie object.
      */
-    map<RM>(callback: ElementCallback<string, R, string, Trie<R>>, toElementFn?: (rawElement: RM) => string, thisArg?: any): Trie<RM>;
+    map<RM>(callback: ElementCallback<string, R, string>, toElementFn?: (rawElement: RM) => string, thisArg?: any): Trie<RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -339,6 +339,7 @@ export declare class Trie<R = any> extends IterableElementBase<string, R, Trie<R
      * trie data structure and yields all the paths to the end nodes.
      */
     protected _getIterator(): IterableIterator<string>;
+    protected get _total(): number;
     /**
      * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.

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

@@ -573,6 +573,9 @@ class Trie extends base_1.IterableElementBase {
         }
         yield* _dfs(this.root, '');
     }
+    get _total() {
+        return this._size;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input string.
      * Space Complexity: O(1) - Constant space.

package/dist/types/data-structures/base/base.d.ts

@@ -1,8 +1,13 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, container: IterableEntryBase<K, V>) => R;
-export type ElementCallback<E, R, RT, C> = (element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
-export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, container: IterableEntryBase<K, V>) => R;
-export type ReduceElementCallback<E, R, RT, C> = (accumulator: RT, element: E, index: number, container: IterableElementBase<E, R, C>) => RT;
+import { LinearBase } from '../../../data-structures/base/linear-base';
+export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceEntryCallback<K, V, R> = (accumulator: R, value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
+export type ReduceElementCallback<E, R, RT = E> = (accumulator: RT, element: E, index: number, original: IterableElementBase<E, R>) => RT;
+export type ReduceLinearCallback<E, RT = E> = (accumulator: RT, element: E, index: number, original: LinearBase<E>) => RT;
 export type IterableElementBaseOptions<E, R> = {
     toElementFn?: (rawElement: R) => E;
 };
+export type LinearBaseOptions<E, R> = IterableElementBaseOptions<E, R> & {
+    maxLen?: number;
+};

package/dist/types/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -1,2 +1,2 @@
 import type { AVLTreeOptions } from './avl-tree';
-export type AVLTreeMultiMapOptions<K, V, R> = Omit<AVLTreeOptions<K, V, R>, 'isMapMode'> & {};
+export type AVLTreeMultiMapOptions<K, V, R> = AVLTreeOptions<K, V, R> & {};

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -1,2 +1,2 @@
 import type { RedBlackTreeOptions } from './red-black-tree';
-export type TreeMultiMapOptions<K, V, R> = Omit<RedBlackTreeOptions<K, V, R>, 'isMapMode'> & {};
+export type TreeMultiMapOptions<K, V, R> = RedBlackTreeOptions<K, V, R> & {};

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

@@ -1,2 +1,2 @@
-import { IterableElementBaseOptions } from '../base';
-export type DoublyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+import { LinearBaseOptions } from '../base';
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

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

@@ -1,2 +1,2 @@
-import { IterableElementBaseOptions } from '../base';
-export type SinglyLinkedListOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+import { LinearBaseOptions } from '../base';
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};

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

@@ -1,5 +1,4 @@
-import { IterableElementBaseOptions } from '../base';
+import { LinearBaseOptions } from '../base';
 export type DequeOptions<E, R> = {
     bucketSize?: number;
-    maxLen?: number;
-} & IterableElementBaseOptions<E, R>;
+} & LinearBaseOptions<E, R>;

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

@@ -1,4 +1,4 @@
-import { IterableElementBaseOptions } from '../base';
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+import { LinearBaseOptions } from '../base';
+export type QueueOptions<E, R> = LinearBaseOptions<E, R> & {
     autoCompactRatio?: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undirected-graph-typed",
-  "version": "1.54.3",
+  "version": "2.0.1",
   "description": "Undirected Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -145,6 +145,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.54.3"
+    "data-structure-typed": "^2.0.1"
   }
 }

package/src/data-structures/base/iterable-element-base.ts

@@ -1,6 +1,6 @@
 import { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
 
-export abstract class IterableElementBase<E, R, C> {
+export abstract class IterableElementBase<E, R> {
   /**
    * The protected constructor initializes the options for the IterableElementBase class, including the
    * toElementFn function.
@@ -14,17 +14,8 @@ export abstract class IterableElementBase<E, R, C> {
     }
   }
 
-  abstract get size(): number;
-
   protected _toElementFn?: (rawElement: R) => E;
 
-  /**
-   * The function returns the _toElementFn property, which is a function that converts a raw element to
-   * a specific type.
-   * @returns The function `get toElementFn()` is returning either a function that takes a raw element
-   * `rawElement` of type `R` and returns an element `E`, or `undefined` if no function is assigned to
-   * `_toElementFn`.
-   */
   get toElementFn(): ((rawElement: R) => E) | undefined {
     return this._toElementFn;
   }
@@ -68,7 +59,7 @@ export abstract class IterableElementBase<E, R, C> {
    * @returns The `every` method is returning a boolean value. It returns `true` if every element in
    * the array satisfies the provided predicate function, and `false` otherwise.
    */
-  every(predicate: ElementCallback<E, R, boolean, C>, thisArg?: any): boolean {
+  every(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
       if (!predicate.call(thisArg, item, index++, this)) {
@@ -92,7 +83,7 @@ export abstract class IterableElementBase<E, R, C> {
    * @returns a boolean value. It returns true if the predicate function returns true for any element
    * in the collection, and false otherwise.
    */
-  some(predicate: ElementCallback<E, R, boolean, C>, thisArg?: any): boolean {
+  some(predicate: ElementCallback<E, R, boolean>, thisArg?: any): boolean {
     let index = 0;
     for (const item of this) {
       if (predicate.call(thisArg, item, index++, this)) {
@@ -115,20 +106,23 @@ export abstract class IterableElementBase<E, R, C> {
    * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
    * be passed as the `this` value to the `callbackfn` function. If `thisArg
    */
-  forEach(callbackfn: ElementCallback<E, R, void, C>, thisArg?: any): void {
+  forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: any): void {
     let index = 0;
     for (const item of this) {
       callbackfn.call(thisArg, item, index++, this);
     }
   }
 
+  find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: any): S | undefined;
+  find(predicate: ElementCallback<E, R, unknown>, thisArg?: any): E | undefined;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `find` function iterates over the elements of an array-like object and returns the first
    * element that satisfies the provided callback function.
-   * @param callbackfn - The callbackfn parameter is a function that will be called for each element in
+   * @param predicate - The predicate parameter is a function that will be called for each element in
    * the array. It takes three arguments: the current element being processed, the index of the current
    * element, and the array itself. The function should return a boolean value indicating whether the
    * current element matches the desired condition.
@@ -138,10 +132,10 @@ export abstract class IterableElementBase<E, R, C> {
    * @returns The `find` method returns the first element in the array that satisfies the provided
    * callback function. If no element satisfies the callback function, `undefined` is returned.
    */
-  find(callbackfn: ElementCallback<E, R, boolean, C>, thisArg?: any): E | undefined {
+  find(predicate: ElementCallback<E, R, boolean>, thisArg?: any): E | undefined {
     let index = 0;
     for (const item of this) {
-      if (callbackfn.call(thisArg, item, index++, this)) return item;
+      if (predicate.call(thisArg, item, index++, this)) return item;
     }
 
     return;
@@ -164,6 +158,10 @@ export abstract class IterableElementBase<E, R, C> {
     return false;
   }
 
+  reduce(callbackfn: ReduceElementCallback<E, R>): E;
+  reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;
+  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -177,15 +175,26 @@ export abstract class IterableElementBase<E, R, C> {
    * @returns The `reduce` method is returning the final value of the accumulator after iterating over
    * all the elements in the array and applying the callback function to each element.
    */
-  reduce<U>(callbackfn: ReduceElementCallback<E, R, U, C>, initialValue: U): U {
-    let accumulator = initialValue;
+  reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue?: U): U {
+    let accumulator = initialValue ?? (0 as U);
     let index = 0;
     for (const item of this) {
-      accumulator = callbackfn(accumulator, item as E, index++, this);
+      accumulator = callbackfn(accumulator, item, index++, this);
     }
     return accumulator;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `toArray` function converts a linked list into an array.
+   * @returns The `toArray()` method is returning an array of type `E[]`.
+   */
+  toArray(): E[] {
+    return [...this];
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -210,7 +219,7 @@ export abstract class IterableElementBase<E, R, C> {
 
   abstract clear(): void;
 
-  abstract clone(): C;
+  abstract clone(): IterableElementBase<E, R>;
 
   abstract map(...args: any[]): any;