perf: Optimize the performance of indexOf, lastIndexOf, slice, and splice methods in Queue, Deque, SinglyLinkedList, and DoublyLinkedList. The performance is now satisfactory with a dataset of 1 million elements.

docs: Add example code for Deque.

CHANGELOG.md

@@ -8,7 +8,7 @@ All notable changes to this project will be documented in this file.
 - [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 - [`auto-changelog`](https://github.com/CookPete/auto-changelog)
 
-## [v1.54.2](https://github.com/zrwusa/data-structure-typed/compare/v1.51.5...main) (upcoming)
+## [v1.54.3](https://github.com/zrwusa/data-structure-typed/compare/v1.51.5...main) (upcoming)
 
 ### Changes
 

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "data-structure-typed",
-  "version": "1.54.2",
+  "version": "1.54.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "data-structure-typed",
-      "version": "1.54.2",
+      "version": "1.54.3",
       "license": "MIT",
       "devDependencies": {
         "@eslint/compat": "^1.2.2",
@@ -19,11 +19,11 @@
         "@typescript-eslint/eslint-plugin": "^8.12.1",
         "@typescript-eslint/parser": "^8.12.1",
         "auto-changelog": "^2.5.0",
-        "avl-tree-typed": "^1.54.1",
+        "avl-tree-typed": "^1.54.3",
         "benchmark": "^2.1.4",
-        "binary-tree-typed": "^1.54.1",
-        "bst-typed": "^1.54.1",
-        "data-structure-typed": "^1.54.2",
+        "binary-tree-typed": "^1.54.3",
+        "bst-typed": "^1.54.3",
+        "data-structure-typed": "^1.54.3",
         "dependency-cruiser": "^16.5.0",
         "doctoc": "^2.2.1",
         "eslint": "^9.13.0",
@@ -32,7 +32,7 @@
         "eslint-import-resolver-typescript": "^3.6.3",
         "eslint-plugin-import": "^2.31.0",
         "fast-glob": "^3.3.2",
-        "heap-typed": "^1.54.1",
+        "heap-typed": "^1.54.3",
         "istanbul-badges-readme": "^1.9.0",
         "jest": "^29.7.0",
         "js-sdsl": "^4.4.2",
@@ -3450,13 +3450,13 @@
       }
     },
     "node_modules/avl-tree-typed": {
-      "version": "1.54.1",
-      "resolved": "https://registry.npmjs.org/avl-tree-typed/-/avl-tree-typed-1.54.1.tgz",
-      "integrity": "sha512-PhaVjii3L+vm57mf/AplYZeIFuUoe8AS470ULkiBiLICt5g3O5FlP/B7JMMl8EyzDz3NyA9XcQXW3gwZ7mEL8w==",
+      "version": "1.54.3",
+      "resolved": "https://registry.npmjs.org/avl-tree-typed/-/avl-tree-typed-1.54.3.tgz",
+      "integrity": "sha512-lJYYqt0rdS6iPDhh7hbaMGkxur9/GJLljas1LqojMZbLmUabVx4T4MszdsCghJy94wThlXN+jjMeCxVB4k4XRw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "data-structure-typed": "^1.54.1"
+        "data-structure-typed": "^1.54.3"
       }
     },
     "node_modules/babel-jest": {
@@ -3615,13 +3615,13 @@
       }
     },
     "node_modules/binary-tree-typed": {
-      "version": "1.54.1",
-      "resolved": "https://registry.npmjs.org/binary-tree-typed/-/binary-tree-typed-1.54.1.tgz",
-      "integrity": "sha512-lYFAKI9bCqA0yrXZYnoUU2szPng1JgyUanGOoqbgIuDncPY3jNnmRZYHUCgwkRi7mu2ukfoUIohP/JSH3g6MTg==",
+      "version": "1.54.3",
+      "resolved": "https://registry.npmjs.org/binary-tree-typed/-/binary-tree-typed-1.54.3.tgz",
+      "integrity": "sha512-azYUQ8qCx5JHKEqZvaxKpSWN7BrYccW729CIc61G7/0ECCzw8AJxYL1jHIzfYTUJgRxGxbzsCkRMjaKaVtuD5w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "data-structure-typed": "^1.54.1"
+        "data-structure-typed": "^1.54.3"
       }
     },
     "node_modules/brace-expansion": {
@@ -3705,13 +3705,13 @@
       }
     },
     "node_modules/bst-typed": {
-      "version": "1.54.1",
-      "resolved": "https://registry.npmjs.org/bst-typed/-/bst-typed-1.54.1.tgz",
-      "integrity": "sha512-2wfrlfxeVdHMfXOJ8Uw7DOFpzBgw6weaE1u6ZrHdJhvgP1cWanpd3Vasnq8EI5g/NjAjH4hCaWkCRaDPjXyjKw==",
+      "version": "1.54.3",
+      "resolved": "https://registry.npmjs.org/bst-typed/-/bst-typed-1.54.3.tgz",
+      "integrity": "sha512-4E4HWana/ON/KZSrOPghMhF81H9G7U9nt9nXvJx2CKCc30qAH8rC/RC9gtxyLoB1QziUFHL73ZNyWORP1wR3cQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "data-structure-typed": "^1.54.1"
+        "data-structure-typed": "^1.54.3"
       }
     },
     "node_modules/buffer-from": {
@@ -4083,9 +4083,9 @@
       }
     },
     "node_modules/data-structure-typed": {
-      "version": "1.54.2",
-      "resolved": "https://registry.npmjs.org/data-structure-typed/-/data-structure-typed-1.54.2.tgz",
-      "integrity": "sha512-H4Ct6XqKsGk7O6/6mb9MHsZdrp5fAYHTgv2Tb+LrbTHnbenKu2ZfM0wP7fbrkhrRPzCFFvZKKDTfSatgykolmw==",
+      "version": "1.54.3",
+      "resolved": "https://registry.npmjs.org/data-structure-typed/-/data-structure-typed-1.54.3.tgz",
+      "integrity": "sha512-hAJ+2cbsfAWMHNP3lupdM9Fji3nqu2jQECWlJ9Hcy7g/Iwu90Xj0YwN3qfTlae86fnMZniv3nVWoeuEhTpMWng==",
       "dev": true,
       "license": "MIT"
     },
@@ -5904,13 +5904,13 @@
       }
     },
     "node_modules/heap-typed": {
-      "version": "1.54.1",
-      "resolved": "https://registry.npmjs.org/heap-typed/-/heap-typed-1.54.1.tgz",
-      "integrity": "sha512-zIiCZeOC1YSUSxuML63bslyr4PS62DFEA9cEnZRSegppIwKtzsLhmnv4vFCfewbucoHJR+J410zMSsSJH/PW1g==",
+      "version": "1.54.3",
+      "resolved": "https://registry.npmjs.org/heap-typed/-/heap-typed-1.54.3.tgz",
+      "integrity": "sha512-XdfkyJuiKnXrfV8vSGNonu+7nON35BuP7/EBt7m8hIipsgxQT4d21pgCwNhsU1TH5xawV9sr6P1GSZkqrQOMZA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "data-structure-typed": "^1.54.1"
+        "data-structure-typed": "^1.54.3"
       }
     },
     "node_modules/html-escaper": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.54.2",
+  "version": "1.54.3",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -65,11 +65,11 @@
     "@typescript-eslint/eslint-plugin": "^8.12.1",
     "@typescript-eslint/parser": "^8.12.1",
     "auto-changelog": "^2.5.0",
-    "avl-tree-typed": "^1.54.1",
+    "avl-tree-typed": "^1.54.3",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.54.1",
-    "bst-typed": "^1.54.1",
-    "data-structure-typed": "^1.54.2",
+    "binary-tree-typed": "^1.54.3",
+    "bst-typed": "^1.54.3",
+    "data-structure-typed": "^1.54.3",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",
@@ -78,7 +78,7 @@
     "eslint-import-resolver-typescript": "^3.6.3",
     "eslint-plugin-import": "^2.31.0",
     "fast-glob": "^3.3.2",
-    "heap-typed": "^1.54.1",
+    "heap-typed": "^1.54.3",
     "istanbul-badges-readme": "^1.9.0",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

scripts/testToExample.ts

@@ -45,6 +45,14 @@ const dirMap: Record<string, string | string[]> = {
   Trie: "trie-typed",
   UndirectedGraph: "undirected-graph-typed",
 };
+
+const classMap: Record<string, string> = {
+  Bst: "BST",
+  AvlTree: "AVLTree",
+  AvlTreeMultiMap: "AVLTreeMultiMap",
+  AvlTreeCounter: "AVLTreeCounter"
+}
+
 const fileName = 'README.md';
 
 /**
@@ -218,6 +226,8 @@ function updateExamples(testDir: string, sourceBaseDir: string): void {
     const sourceFilePath = path.resolve(sourceBaseDir, relativePath.replace('.test.ts', '.ts'));
     let className = toPascalCase(path.basename(sourceFilePath, '.ts'));
     if (className === 'Bst') className = 'BST';
+    if (className === 'AvlTree') className = 'AVLTree';
+    className = classMap[className] || className;
     addExamplesToSourceFile(sourceFilePath, className, examples);
     const dirKey = dirMap[className];
 

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;
 

src/data-structures/base/linear-base.ts

@@ -0,0 +1,649 @@
+import { ElementCallback, LinearBaseOptions, ReduceLinearCallback } from '../../types';
+import { IterableElementBase } from './iterable-element-base';
+
+export class LinkedListNode<E = any> {
+  constructor(value: E) {
+    this._value = value;
+    this._next = undefined;
+  }
+
+  protected _value: E;
+
+  get value(): E {
+    return this._value;
+  }
+
+  set value(value: E) {
+    this._value = value;
+  }
+
+  protected _next: LinkedListNode<E> | undefined;
+
+  get next(): LinkedListNode<E> | undefined {
+    return this._next;
+  }
+
+  set next(value: LinkedListNode<E> | undefined) {
+    this._next = value;
+  }
+}
+
+export abstract class LinearBase<
+  E,
+  R = any,
+  NODE extends LinkedListNode<E> = LinkedListNode<E>
+> extends IterableElementBase<E, R> {
+  /**
+   * The constructor initializes the LinearBase class with optional options, setting the maximum length
+   * if provided.
+   * @param [options] - The `options` parameter is an optional object that can be passed to the
+   * constructor. It is of type `LinearBaseOptions<E, R>`. The constructor checks if the `options`
+   * object is provided and then extracts the `maxLen` property from it. If `maxLen` is a
+   */
+  protected constructor(options?: LinearBaseOptions<E, R>) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+
+  abstract get length(): number;
+
+  protected _maxLen: number = -1;
+
+  get maxLen() {
+    return this._maxLen;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function indexOf searches for a specified element starting from a given index in an array-like
+   * object and returns the index of the first occurrence, or -1 if not found.
+   * @param {E} searchElement - The `searchElement` parameter in the `indexOf` function represents the
+   * element that you want to find within the array. The function will search for this element starting
+   * from the `fromIndex` (if provided) up to the end of the array. If the `searchElement` is found
+   * within the
+   * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` function represents the
+   * index at which to start searching for the `searchElement` within the array. If provided, the
+   * search will begin at this index and continue to the end of the array. If `fromIndex` is not
+   * specified, the default
+   * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
+   * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
+   */
+  indexOf(searchElement: E, fromIndex: number = 0): number {
+    // Boundary checks and adjustments
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+
+    // Iterating from the specified index to the end
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+
+    return -1; // Not found
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `lastIndexOf` in TypeScript returns the index of the last occurrence of a specified
+   * element in an array.
+   * @param {E} searchElement - The `searchElement` parameter is the element that you want to find the
+   * last index of within the array. The `lastIndexOf` method will search the array starting from the
+   * `fromIndex` (or the end of the array if not specified) and return the index of the last occurrence
+   * of the
+   * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
+   * index at which to start searching for the `searchElement` in the array. By default, it starts
+   * searching from the last element of the array (`this.length - 1`). If a specific `fromIndex` is
+   * provided
+   * @returns The last index of the `searchElement` in the array is being returned. If the
+   * `searchElement` is not found in the array, -1 is returned.
+   */
+  lastIndexOf(searchElement: E, fromIndex: number = this.length - 1): number {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+
+    return -1;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `findIndex` function iterates over an array and returns the index of the first element that
+   * satisfies the provided predicate function.
+   * @param predicate - The `predicate` parameter in the `findIndex` function is a callback function
+   * that takes three arguments: `item`, `index`, and the array `this`. It should return a boolean
+   * value indicating whether the current element satisfies the condition being checked for.
+   * @param {any} [thisArg] - The `thisArg` parameter in the `findIndex` function is an optional
+   * parameter that specifies the value to use as `this` when executing the `predicate` function. If
+   * provided, the `predicate` function will be called with `thisArg` as its `this` value. If `
+   * @returns The `findIndex` method is returning the index of the first element in the array that
+   * satisfies the provided predicate function. If no such element is found, it returns -1.
+   */
+  findIndex(predicate: ElementCallback<E, R, boolean>, thisArg?: any): number {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== undefined && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+
+  concat(...items: this[]): this;
+
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(n + m)
+   *
+   * The `concat` function in TypeScript concatenates multiple items into a new list, handling both
+   * individual elements and instances of `LinearBase`.
+   * @param {(E | this)[]} items - The `concat` method takes in an array of items, where
+   * each item can be either of type `E` or an instance of `LinearBase<E, R>`.
+   * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
+   * items passed as arguments concatenated to it.
+   */
+  concat(...items: (E | this)[]): this {
+    const newList = this.clone();
+
+    for (const item of items) {
+      if (item instanceof LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+
+    return newList;
+  }
+
+  /**
+   * Time Complexity: O(n log n)
+   * Space Complexity: O(n)
+   *
+   * The `sort` function in TypeScript sorts the elements of a collection using a specified comparison
+   * function.
+   * @param [compareFn] - The `compareFn` parameter is a function that defines the sort order. It takes
+   * two elements `a` and `b` as input and returns a number indicating their relative order. If the
+   * returned value is negative, `a` comes before `b`. If the returned value is positive, `
+   * @returns The `sort` method is returning the instance of the object on which it is called (this),
+   * after sorting the elements based on the provided comparison function (compareFn).
+   */
+  sort(compareFn?: (a: E, b: E) => number): this {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(m)
+   *
+   * The `splice` function in TypeScript removes elements from an array and optionally inserts new
+   * elements at the specified index.
+   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+   * to start modifying the array. If `start` is a negative number, it will count from the end of the
+   * array.
+   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided or is 0, no elements are removed, and only new elements are inserted
+   * at the `start`
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be inserted into the array at the specified `start` index. These elements can be of any type
+   * and you can pass multiple elements separated by commas. The `splice` method will insert these
+   * items into the array at the
+   * @returns The `splice` method returns a list of elements that were removed from the original list
+   * during the operation.
+   */
+  splice(start: number, deleteCount: number = 0, ...items: E[]): this {
+    const removedList = this._createInstance();
+
+    // Handling negative indexes and bounds
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+
+    // Delete elements
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start); // Always delete the start position
+      if (removed !== undefined) {
+        removedList.push(removed); // Add removed elements to the returned list
+      }
+    }
+
+    // Insert new element
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]); // Insert new elements one by one at the current position
+    }
+
+    return removedList; // Returns a list of removed elements
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `join` function in TypeScript returns a string by joining the elements of an array with a
+   * specified separator.
+   * @param {string} [separator=,] - The `separator` parameter is a string that specifies the character
+   * or characters that will be used to separate each element when joining them into a single string.
+   * By default, the separator is set to a comma (`,`), but you can provide a different separator if
+   * needed.
+   * @returns The `join` method is being returned, which takes an optional `separator` parameter
+   * (defaulting to a comma) and returns a string created by joining all elements of the array after
+   * converting it to an array.
+   */
+  join(separator: string = ','): string {
+    return this.toArray().join(separator);
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function `toReversedArray` takes an array and returns a new array with its elements in reverse
+   * order.
+   * @returns The `toReversedArray()` function returns an array of elements of type `E` in reverse
+   * order.
+   */
+  toReversedArray(): E[] {
+    const array: E[] = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i)!);
+    }
+    return array;
+  }
+
+  reduceRight(callbackfn: ReduceLinearCallback<E>): E;
+
+  reduceRight(callbackfn: ReduceLinearCallback<E>, initialValue: E): E;
+
+  reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `reduceRight` function in TypeScript iterates over an array from right to left and applies a
+   * callback function to each element, accumulating a single result.
+   * @param callbackfn - The `callbackfn` parameter in the `reduceRight` method is a function that will
+   * be called on each element in the array from right to left. It takes four arguments:
+   * @param {U} [initialValue] - The `initialValue` parameter in the `reduceRight` method is an
+   * optional parameter that specifies the initial value of the accumulator. If provided, the
+   * `accumulator` will start with this initial value before iterating over the elements of the array.
+   * If `initialValue` is not provided, the accumulator will
+   * @returns The `reduceRight` method is returning the final accumulated value after applying the
+   * callback function to each element in the array from right to left.
+   */
+  reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue?: U): U {
+    let accumulator = initialValue ?? (0 as U);
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i)!, i, this);
+    }
+    return accumulator;
+  }
+
+  /**
+   * Time Complexity: O(m)
+   * Space Complexity: O(m)
+   *
+   * The `slice` function in TypeScript creates a new instance by extracting a portion of elements from
+   * the original instance based on the specified start and end indices.
+   * @param {number} [start=0] - The `start` parameter in the `slice` method represents the index at
+   * which to begin extracting elements from an array-like object. If no `start` parameter is provided,
+   * the default value is 0, meaning the extraction will start from the beginning of the array.
+   * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
+   * end the slicing. By default, if no `end` parameter is provided, it will slice until the end of the
+   * array (i.e., `this.length`).
+   * @returns The `slice` method is returning a new instance of the object with elements sliced from
+   * the specified start index (default is 0) to the specified end index (default is the length of the
+   * object).
+   */
+  slice(start: number = 0, end: number = this.length): this {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i)!);
+    }
+    return newList;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `fill` function in TypeScript fills a specified range in an array-like object with a given
+   * value.
+   * @param {E} value - The `value` parameter in the `fill` method represents the element that will be
+   * used to fill the specified range in the array.
+   * @param [start=0] - The `start` parameter specifies the index at which to start filling the array
+   * with the specified value. If not provided, it defaults to 0, indicating the beginning of the
+   * array.
+   * @param end - The `end` parameter in the `fill` function represents the index at which the filling
+   * of values should stop. It specifies the end of the range within the array where the `value` should
+   * be filled.
+   * @returns The `fill` method is returning the modified object (`this`) after filling the specified
+   * range with the provided value.
+   */
+  fill(value: E, start = 0, end = this.length): this {
+    // Handling negative indexes
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+
+    // Boundary processing
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+
+    // Iterate through the specified range and fill in the values
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+
+    return this;
+  }
+
+  abstract setAt(index: number, value: E): boolean;
+
+  abstract override clone(): this;
+
+  abstract reverse(): this;
+
+  abstract push(elementOrNode: E | NODE): boolean;
+
+  abstract pushMany(elements: Iterable<E> | Iterable<R> | Iterable<NODE>): boolean[];
+
+  abstract delete(elementOrNode: E | NODE | undefined): boolean;
+
+  abstract at(index: number): E | undefined;
+
+  abstract deleteAt(pos: number): E | undefined;
+
+  abstract addAt(index: number, newElementOrNode: E | NODE): boolean;
+
+  protected abstract _createInstance(options?: LinearBaseOptions<E, R>): this;
+
+  protected abstract _getReverseIterator(...args: any[]): IterableIterator<E>;
+}
+
+export abstract class LinearLinkedBase<
+  E,
+  R = any,
+  NODE extends LinkedListNode<E> = LinkedListNode<E>
+> extends LinearBase<E, R, NODE> {
+  /**
+   * The constructor initializes the LinearBase class with optional options, setting the maximum length
+   * if provided and valid.
+   * @param [options] - The `options` parameter is an optional object that can be passed to the
+   * constructor. It is of type `LinearBaseOptions<E, R>`. This object may contain properties such as
+   * `maxLen`, which is a number representing the maximum length. If `maxLen` is a positive integer,
+   */
+  protected constructor(options?: LinearBaseOptions<E, R>) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function overrides the indexOf method to improve performance by searching for an element in a
+   * custom array implementation starting from a specified index.
+   * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+   * within the array. The `indexOf` method will return the index of the first occurrence of this
+   * element within the array.
+   * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+   * index in the array at which to start the search for the `searchElement`. If provided, the search
+   * will begin at the specified index and continue to the end of the array. If not provided, the
+   * search will start at index
+   * @returns The `indexOf` method is returning the index of the `searchElement` if it is found in the
+   * array starting from the `fromIndex`. If the `searchElement` is not found, it returns -1.
+   */
+  override indexOf(searchElement: E, fromIndex: number = 0): number {
+    // In order to improve performance, it is best to override this method in the subclass of the array implementation
+    const iterator = this._getIterator();
+    let current = iterator.next();
+
+    let index = 0;
+    while (index < fromIndex) {
+      current = iterator.next();
+      index++;
+    }
+
+    while (!current.done) {
+      if (current.value === searchElement) return index;
+      current = iterator.next();
+      index++;
+    }
+
+    return -1;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function overrides the lastIndexOf method in TypeScript to improve performance by searching
+   * for an element in reverse order starting from a specified index.
+   * @param {E} searchElement - The `searchElement` parameter is the element that you want to find
+   * within the array. The `lastIndexOf` method searches the array for this element starting from the
+   * end of the array (or from the specified `fromIndex` if provided) and returns the index of the last
+   * occurrence of the element
+   * @param {number} fromIndex - The `fromIndex` parameter in the `lastIndexOf` method specifies the
+   * index at which to start searching for the `searchElement` in the array. If provided, the search
+   * will begin at this index and move towards the beginning of the array. If not provided, the search
+   * will start at the
+   * @returns The `lastIndexOf` method is being overridden to search for the `searchElement` starting
+   * from the specified `fromIndex` (defaulting to the end of the array). It iterates over the array in
+   * reverse order using a custom iterator `_getReverseIterator` and returns the index of the last
+   * occurrence of the `searchElement` if found, or -1 if not found.
+   */
+  override lastIndexOf(searchElement: E, fromIndex: number = this.length - 1): number {
+    // In order to improve performance, it is best to override this method in the subclass of the array implementation
+    const iterator = this._getReverseIterator();
+    let current = iterator.next();
+
+    let index = this.length - 1;
+    while (index > fromIndex) {
+      current = iterator.next();
+      index--;
+    }
+
+    while (!current.done) {
+      if (current.value === searchElement) return index;
+      current = iterator.next();
+      index--;
+    }
+
+    return -1;
+  }
+
+  override concat(...items: LinearBase<E, R>[]): this;
+
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(n + m)
+   *
+   * The `concat` function in TypeScript overrides the default behavior to concatenate items into a new
+   * list, handling both individual elements and instances of `LinearBase`.
+   * @param {(E | LinearBase<E, R>)[]} items - The `concat` method you provided takes in a variable
+   * number of arguments of type `E` or `LinearBase<E, R>`. The method concatenates these items to the
+   * current list and returns a new list with the concatenated items.
+   * @returns The `concat` method is returning a new instance of the class that it belongs to, with the
+   * items passed as arguments concatenated to it.
+   */
+  override concat(...items: (E | LinearBase<E, R>)[]): this {
+    const newList = this.clone();
+
+    for (const item of items) {
+      if (item instanceof LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+
+    return newList;
+  }
+
+  /**
+   * Time Complexity: O(m)
+   * Space Complexity: O(m)
+   *
+   * The `slice` method is overridden to improve performance by creating a new instance and iterating
+   * through the array to extract a subset based on the specified start and end indices.
+   * @param {number} [start=0] - The `start` parameter in the `slice` method specifies the index at
+   * which to begin extracting elements from the array. If no `start` parameter is provided, the
+   * default value is 0, indicating that extraction should start from the beginning of the array.
+   * @param {number} end - The `end` parameter in the `slice` method represents the index at which to
+   * end the slicing of the array. If not provided, it defaults to the length of the array.
+   * @returns The `slice` method is returning a new instance of the array implementation with elements
+   * sliced from the original array based on the `start` and `end` parameters.
+   */
+  override slice(start: number = 0, end: number = this.length): this {
+    // In order to improve performance, it is best to override this method in the subclass of the array implementation
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+
+    const newList = this._createInstance();
+    const iterator = this._getIterator();
+    let current = iterator.next();
+    let c = 0;
+    while (c < start) {
+      current = iterator.next();
+      c++;
+    }
+    for (let i = start; i < end; i++) {
+      newList.push(current.value);
+      current = iterator.next();
+    }
+
+    return newList;
+  }
+
+  /**
+   * Time Complexity: O(n + m)
+   * Space Complexity: O(m)
+   *
+   * The function overrides the splice method to handle deletion and insertion of elements in a data
+   * structure while returning the removed elements.
+   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+   * to start modifying the array.
+   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+   * elements can still be inserted at
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be inserted into the array at the specified `start` index. These elements can be of any type
+   * and there can be multiple elements passed as arguments to be inserted into the array.
+   * @returns The `splice` method is returning a new instance of the data structure that was modified
+   * by removing elements specified by the `start` and `deleteCount` parameters, and inserting new
+   * elements provided in the `items` array.
+   */
+  override splice(start: number, deleteCount: number = 0, ...items: E[]): this {
+    const removedList = this._createInstance(); // Used to store deleted elements
+
+    // Handling negative indexes
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length)); // Correct start range
+    deleteCount = Math.max(0, deleteCount); // Make sure deleteCount is non-negative
+
+    let currentIndex = 0;
+    let currentNode: NODE | undefined = undefined;
+    let previousNode: NODE | undefined = undefined;
+
+    // Find the starting point using an iterator
+    const iterator = this._getNodeIterator();
+    for (const node of iterator) {
+      if (currentIndex === start) {
+        currentNode = node; // Find the starting node
+        break;
+      }
+      previousNode = node; // Update the previous node
+      currentIndex++;
+    }
+
+    // Delete nodes
+    for (let i = 0; i < deleteCount && currentNode; i++) {
+      removedList.push(currentNode.value); // Store the deleted value in removedList
+      const nextNode = currentNode.next; // Save next node
+      this.delete(currentNode); // Delete current node
+      currentNode = nextNode as NODE;
+    }
+
+    // Insert new value
+    for (let i = 0; i < items.length; i++) {
+      if (previousNode) {
+        this.addAfter(previousNode, items[i]); // Insert after previousNode
+        previousNode = previousNode.next as NODE; // Move to newly inserted node
+      } else {
+        this.addAt(0, items[i]); // Insert at the head of the linked list
+        previousNode = this._getNodeIterator().next().value; // Update the head node to be the first inserted node
+      }
+    }
+
+    return removedList;
+  }
+
+  override reduceRight(callbackfn: ReduceLinearCallback<E>): E;
+
+  override reduceRight(callbackfn: ReduceLinearCallback<E>, initialValue: E): E;
+
+  override reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue: U): U;
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `reduceRight` iterates over an array in reverse order and applies a callback function
+   * to each element, accumulating a single result.
+   * @param callbackfn - The `callbackfn` parameter is a function that will be called on each element
+   * of the array from right to left. It takes four arguments:
+   * @param {U} [initialValue] - The `initialValue` parameter is an optional value that is used as the
+   * initial accumulator value in the reduce operation. If provided, the reduce operation starts with
+   * this initial value and iterates over the elements of the array, applying the callback function to
+   * each element and the current accumulator value. If `initial
+   * @returns The `reduceRight` method is returning the final accumulated value after applying the
+   * callback function to each element in the array from right to left.
+   */
+  override reduceRight<U>(callbackfn: ReduceLinearCallback<E, U>, initialValue?: U): U {
+    let accumulator = initialValue ?? (0 as U);
+    let index = this.length - 1;
+    for (const item of this._getReverseIterator()) {
+      accumulator = callbackfn(accumulator, item, index--, this);
+    }
+    return accumulator;
+  }
+
+  abstract override delete(elementOrNode: E | NODE | undefined): boolean;
+
+  abstract addBefore(existingElementOrNode: E | NODE, newElementOrNode: E | NODE): boolean;
+
+  abstract addAfter(existingElementOrNode: E | NODE, newElementOrNode: E | NODE): boolean;
+
+  abstract getNodeAt(index: number): NODE | undefined;
+
+  protected abstract _getNodeIterator(...args: any[]): IterableIterator<NODE>;
+
+  // protected abstract _getReverseNodeIterator(...args: any[]): IterableIterator<NODE>;
+
+  protected abstract _getPrevNode(node: NODE): NODE | undefined;
+}

src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -100,6 +100,7 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
+      isMapMode: this._isMapMode,
       ...options
     });
   }
@@ -108,19 +109,23 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `createNode` overrides the method to create a new AVLTreeMultiMapNode with a
-   * specified key and an empty array of values.
-   * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-   * that will be created in the AVLTreeMultiMap.
-   * @returns An AVLTreeMultiMapNode object is being returned, initialized with the provided key and an
-   * empty array.
+   * The `createNode` function in TypeScript overrides the default implementation to create a new
+   * AVLTreeMultiMapNode with a specified key and value array.
+   * @param {K} key - The `key` parameter represents the key of the node being created in the
+   * AVLTreeMultiMap.
+   * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+   * values associated with a specific key in the AVLTreeMultiMapNode. If no value is provided when
+   * calling the method, an empty array `[]` is used as the default value.
+   * @returns An AVLTreeMultiMapNode object is being returned, with the specified key and value. If the
+   * AVLTreeMultiMap is in map mode, an empty array is used as the value, otherwise the provided value
+   * array is used.
    */
-  override createNode(key: K): AVLTreeMultiMapNode<K, V> {
-    return new AVLTreeMultiMapNode<K, V>(key, []);
+  override createNode(key: K, value: V[] = []): AVLTreeMultiMapNode<K, V> {
+    return new AVLTreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
   override add(
-    node: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+    keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
   override add(key: K, value: V): boolean;
@@ -129,17 +134,16 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
    * Time Complexity: O(log n)
    * Space Complexity: O(log n)
    *
-   * The function `add` in TypeScript overrides the superclass method to add key-value pairs to an AVL
-   * tree multi-map.
-   * @param {K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `override add` method can be either a key-value pair entry or just a key. If it
-   * is a key-value pair entry, it will be in the format `[key, values]`, where `key` is the key and
-   * `values`
-   * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-   * you want to add to the AVLTreeMultiMap. It can be a single value or an array of values associated
-   * with a specific key.
-   * @returns The `override add` method is returning a boolean value, which indicates whether the
-   * addition operation was successful or not.
+   * The function `add` in this TypeScript code overrides the superclass method to add key-value pairs
+   * to an AVLTreeMultiMap, handling different input types and scenarios.
+   * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+   * be added to the AVLTreeMultiMap. It can be of type `K`, which is the key type of the map. The key
+   * can be a single key value, a node of the AVLTree
+   * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+   * that you want to add to the AVLTreeMultiMap. It can contain one or more values associated with a
+   * specific key.
+   * @returns The `add` method is returning a boolean value, which indicates whether the operation was
+   * successful or not.
    */
   override add(
     keyNodeOrEntry: K | AVLTreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined | K,
@@ -150,27 +154,38 @@ export class AVLTreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, M
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const existingValues = this.get(key);
-      if (existingValues !== undefined && values !== undefined) {
-        for (const value of values) existingValues.push(value);
-        return true;
-      }
-
-      const existingNode = this.getNode(key);
-      if (this.isRealNode(existingNode)) {
-        if (existingValues === undefined) {
-          super.add(key, values);
-          return true;
-        }
-        if (values !== undefined) {
+      const _addToValues = () => {
+        const existingValues = this.get(key);
+        if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
           return true;
-        } else {
-          return false;
         }
-      } else {
-        return super.add(key, values);
+        return false;
+      };
+
+      const _addByNode = () => {
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          const existingValues = this.get(existingNode);
+          if (existingValues === undefined) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== undefined) {
+            for (const value of values) existingValues.push(value);
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return super.add(key, values);
+        }
+      };
+
+      if (this._isMapMode) {
+        return _addByNode() || _addToValues();
       }
+      return _addToValues() || _addByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {

src/data-structures/binary-tree/avl-tree.ts

@@ -60,6 +60,70 @@ export class AVLTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 5. Efficient Lookups: Offers O(log n) search time, where 'n' is the number of nodes, due to its balanced nature.
  * 6. Complex Insertions and Deletions: Due to rebalancing, these operations are more complex than in a regular BST.
  * 7. Path Length: The path length from the root to any leaf is longer compared to an unbalanced BST, but shorter than a linear chain of nodes.
+ * @example
+ * // Find elements in a range
+ *     // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
+ *     type Datum = { timestamp: Date; temperature: number };
+ *     // Fixed dataset of CPU temperature readings
+ *     const cpuData: Datum[] = [
+ *       { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+ *       { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+ *       { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+ *       { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+ *       { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+ *       { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+ *       { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+ *       { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+ *       { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+ *       { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+ *       { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+ *       { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+ *       { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+ *       { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+ *       { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+ *       { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+ *       { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+ *       { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+ *       { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+ *       { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+ *       { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+ *       { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+ *       { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+ *       { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+ *       { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+ *       { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+ *       { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+ *       { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+ *       { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+ *       { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+ *     ];
+ *
+ *     // Create an AVL tree to store CPU temperature data
+ *     const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+ *       toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+ *     });
+ *
+ *     // Query a specific time range (e.g., from 00:05 to 00:15)
+ *     const rangeStart = new Date('2024-12-02T00:05:00');
+ *     const rangeEnd = new Date('2024-12-02T00:15:00');
+ *     const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+ *       minute: node ? node.key.getMinutes() : 0,
+ *       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+ *     }));
+ *
+ *     console.log(rangeResults); // [
+ *  //      { minute: 5, temperature: 59.4 },
+ *  //      { minute: 6, temperature: 60.1 },
+ *  //      { minute: 7, temperature: 61.3 },
+ *  //      { minute: 8, temperature: 62 },
+ *  //      { minute: 9, temperature: 63.5 },
+ *  //      { minute: 10, temperature: 64 },
+ *  //      { minute: 11, temperature: 62.8 },
+ *  //      { minute: 12, temperature: 61.5 },
+ *  //      { minute: 13, temperature: 60.2 },
+ *  //      { minute: 14, temperature: 59.8 },
+ *  //      { minute: 15, temperature: 58.6 }
+ *  //    ]
  */
 export class AVLTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends BST<K, V, R, MK, MV, MR>

src/data-structures/binary-tree/binary-tree.ts

@@ -129,6 +129,68 @@ export class BinaryTreeNode<K = any, V = any> {
  * 3. Depth and Height: Depth is the number of edges from the root to a node; height is the maximum depth in the tree.
  * 4. Subtrees: Each child of a node forms the root of a subtree.
  * 5. Leaf Nodes: Nodes without children are leaves.
+ * @example
+ * // determine loan approval using a decision tree
+ *     // Decision tree structure
+ *     const loanDecisionTree = new BinaryTree<string>(
+ *       ['stableIncome', 'goodCredit', 'Rejected', 'Approved', 'Rejected'],
+ *       { isDuplicate: true }
+ *     );
+ *
+ *     function determineLoanApproval(
+ *       node?: BinaryTreeNode<string> | null,
+ *       conditions?: { [key: string]: boolean }
+ *     ): string {
+ *       if (!node) throw new Error('Invalid node');
+ *
+ *       // If it's a leaf node, return the decision result
+ *       if (!node.left && !node.right) return node.key;
+ *
+ *       // Check if a valid condition exists for the current node's key
+ *       return conditions?.[node.key]
+ *         ? determineLoanApproval(node.left, conditions)
+ *         : determineLoanApproval(node.right, conditions);
+ *     }
+ *
+ *     // Test case 1: Stable income and good credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: true })); // 'Approved'
+ *
+ *     // Test case 2: Stable income but poor credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: true, goodCredit: false })); // 'Rejected'
+ *
+ *     // Test case 3: No stable income
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: true })); // 'Rejected'
+ *
+ *     // Test case 4: No stable income and poor credit score
+ *     console.log(determineLoanApproval(loanDecisionTree.root, { stableIncome: false, goodCredit: false })); // 'Rejected'
+ * @example
+ * // evaluate the arithmetic expression represented by the binary tree
+ *     const expressionTree = new BinaryTree<number | string>(['+', 3, '*', null, null, 5, '-', null, null, 2, 8]);
+ *
+ *     function evaluate(node?: BinaryTreeNode<number | string> | null): number {
+ *       if (!node) return 0;
+ *
+ *       if (typeof node.key === 'number') return node.key;
+ *
+ *       const leftValue = evaluate(node.left); // Evaluate the left subtree
+ *       const rightValue = evaluate(node.right); // Evaluate the right subtree
+ *
+ *       // Perform the operation based on the current node's operator
+ *       switch (node.key) {
+ *         case '+':
+ *           return leftValue + rightValue;
+ *         case '-':
+ *           return leftValue - rightValue;
+ *         case '*':
+ *           return leftValue * rightValue;
+ *         case '/':
+ *           return rightValue !== 0 ? leftValue / rightValue : 0; // Handle division by zero
+ *         default:
+ *           throw new Error(`Unsupported operator: ${node.key}`);
+ *       }
+ *     }
+ *
+ *     console.log(evaluate(expressionTree.root)); // -27
  */
 export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends IterableEntryBase<K, V | undefined>
@@ -482,7 +544,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
     const queue = new Queue<BinaryTreeNode<K, V>>([this._root]);
     let potentialParent: BinaryTreeNode<K, V> | undefined; // Record the parent node of the potential insertion location
 
-    while (queue.size > 0) {
+    while (queue.length > 0) {
       const cur = queue.shift();
 
       if (!cur) continue;
@@ -1468,7 +1530,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       ]);
 
       const dfs = (level: number) => {
-        if (queue.size === 0) return;
+        if (queue.length === 0) return;
 
         const current = queue.shift()!;
         ans.push(callback(current));
@@ -1487,8 +1549,8 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       dfs(0);
     } else {
       const queue = new Queue<OptNodeOrNull<BinaryTreeNode<K, V>>>([startNode]);
-      while (queue.size > 0) {
-        const levelSize = queue.size;
+      while (queue.length > 0) {
+        const levelSize = queue.length;
 
         for (let i = 0; i < levelSize; i++) {
           const current = queue.shift()!;
@@ -1547,7 +1609,7 @@ export class BinaryTree<K = any, V = any, R = object, MK = any, MV = any, MR = o
       dfs(startNode);
     } else {
       const queue = new Queue([startNode]);
-      while (queue.size > 0) {
+      while (queue.length > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
           if (this.isLeaf(cur)) {

src/data-structures/binary-tree/bst.ts

@@ -102,9 +102,9 @@ export class BSTNode<K = any, V = any> extends BinaryTreeNode<K, V> {
  * @example
  * // Find elements in a range
  *     const bst = new BST<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(bst.search(new Range(5, 10))); // [10, 5, 7]
- *     console.log(bst.rangeSearch([4, 12], node => node.key.toString())); // ['10', '12', '5', '7']
- *     console.log(bst.search(new Range(4, 12, true, false))); // [10, 5, 7]
+ *     console.log(bst.search(new Range(5, 10))); // [5, 7, 10]
+ *     console.log(bst.rangeSearch([4, 12], node => node.key.toString())); // ['5', '7', '10', '12']
+ *     console.log(bst.search(new Range(4, 12, true, false))); // [5, 7, 10]
  *     console.log(bst.rangeSearch([15, 20])); // [15, 18]
  *     console.log(bst.search(new Range(15, 20, false))); // [18]
  * @example
@@ -441,14 +441,14 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
-      let { key, value } = arr[mid];
+      const { key, value } = arr[mid];
       const { orgIndex } = arr[mid];
       if (this.isRaw(key)) {
         const entry = this._toEntryFn!(key);
-        key = entry[0];
-        value = entry[1] ?? value;
+        inserted[orgIndex] = this.add(entry);
+      } else {
+        inserted[orgIndex] = this.add(key, value);
       }
-      inserted[orgIndex] = this.add(key, value);
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
     };
@@ -462,14 +462,14 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
           const [l, r] = popped;
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
-            let { key, value } = sorted[m];
+            const { key, value } = sorted[m];
             const { orgIndex } = sorted[m];
             if (this.isRaw(key)) {
               const entry = this._toEntryFn!(key);
-              key = entry[0];
-              value = entry[1] ?? value;
+              inserted[orgIndex] = this.add(entry);
+            } else {
+              inserted[orgIndex] = this.add(key, value);
             }
-            inserted[orgIndex] = this.add(key, value);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -792,7 +792,7 @@ export class BST<K = any, V = any, R = object, MK = any, MV = any, MR = object>
       return ans;
     } else {
       const queue = new Queue<BSTNode<K, V>>([this._root]);
-      while (queue.size > 0) {
+      while (queue.length > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
           const compared = this._compare(cur.key, targetKey);

src/data-structures/binary-tree/red-black-tree.ts

@@ -51,12 +51,6 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
  * 1. Efficient self-balancing, but not completely balanced. Compared with AVLTree, the addition and deletion efficiency is high but the query efficiency is slightly lower.
  * 2. It is BST itself. Compared with Heap which is not completely ordered, RedBlackTree is completely ordered.
  * @example
- * // Find elements in a range
- *     const bst = new RedBlackTree<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(bst.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(bst.search(new Range(4, 12))); // [5, 10, 12, 7]
- *     console.log(bst.search(new Range(15, 20))); // [15, 18]
- * @example
  * // using Red-Black Tree as a price-based index for stock data
  *     // Define the structure of individual stock records
  *     interface StockRecord {
@@ -98,7 +92,7 @@ export class RedBlackTreeNode<K = any, V = any> extends BSTNode<K, V> {
  *       [200, 400], // Price range
  *       node => priceIndex.get(node)?.symbol // Extract stock symbols for the result
  *     );
- *     console.log(stocksInRange); // ['GOOGL', 'MSFT', 'META']
+ *     console.log(stocksInRange); // ['GOOGL', 'META', 'MSFT']
  */
 export class RedBlackTree<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends BST<K, V, R, MK, MV, MR>

src/data-structures/binary-tree/tree-multi-map.ts

@@ -21,7 +21,7 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param {V[]} value - The `value` parameter in the constructor represents an array of values of
    * type `V`.
    */
-  constructor(key: K, value: V[]) {
+  constructor(key: K, value?: V[]) {
     super(key, value);
   }
 
@@ -55,11 +55,169 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
 /**
  *
  * @example
- * // Find elements in a range
- *     const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
- *     console.log(tmm.search(new Range(5, 10))); // [5, 10, 7]
- *     console.log(tmm.search(new Range(4, 12))); // [5, 10, 12, 7]
- *     console.log(tmm.search(new Range(15, 20))); // [15, 18]
+ * // players ranked by score with their equipment
+ *     type Equipment = {
+ *       name: string; // Equipment name
+ *       quality: 'legendary' | 'epic' | 'rare' | 'common';
+ *       level: number;
+ *     };
+ *
+ *     type Player = {
+ *       name: string;
+ *       score: number;
+ *       equipments: Equipment[];
+ *     };
+ *
+ *     // Mock player data with their scores and equipment
+ *     const players: Player[] = [
+ *       {
+ *         name: 'DragonSlayer',
+ *         score: 8750,
+ *         equipments: [
+ *           { name: 'AWM', quality: 'legendary', level: 85 },
+ *           { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+ *           { name: 'Compensator', quality: 'epic', level: 78 },
+ *           { name: 'Vertical Grip', quality: 'rare', level: 72 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'ShadowNinja',
+ *         score: 7200,
+ *         equipments: [
+ *           { name: 'M416', quality: 'epic', level: 75 },
+ *           { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 65 },
+ *           { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RuneMaster',
+ *         score: 9100,
+ *         equipments: [
+ *           { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *           { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'BattleKing',
+ *         score: 8500,
+ *         equipments: [
+ *           { name: 'AUG', quality: 'epic', level: 82 },
+ *           { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+ *           { name: 'Extended Mag', quality: 'common', level: 70 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 76 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'SniperElite',
+ *         score: 7800,
+ *         equipments: [
+ *           { name: 'M24', quality: 'legendary', level: 88 },
+ *           { name: 'Compensator', quality: 'epic', level: 80 },
+ *           { name: 'Scope 8x', quality: 'legendary', level: 85 },
+ *           { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'RushMaster',
+ *         score: 7500,
+ *         equipments: [
+ *           { name: 'Vector', quality: 'rare', level: 72 },
+ *           { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+ *           { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+ *           { name: 'Laser Sight', quality: 'rare', level: 68 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'GhostWarrior',
+ *         score: 8200,
+ *         equipments: [
+ *           { name: 'SCAR-L', quality: 'epic', level: 78 },
+ *           { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+ *           { name: 'Holographic Sight', quality: 'epic', level: 75 },
+ *           { name: 'Suppressor', quality: 'rare', level: 72 },
+ *           { name: 'Vertical Grip', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'DeathDealer',
+ *         score: 7300,
+ *         equipments: [
+ *           { name: 'SKS', quality: 'epic', level: 76 },
+ *           { name: 'Holographic Sight', quality: 'rare', level: 68 },
+ *           { name: 'Extended Mag', quality: 'common', level: 65 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'StormRider',
+ *         score: 8900,
+ *         equipments: [
+ *           { name: 'MK14', quality: 'legendary', level: 92 },
+ *           { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *           { name: 'Scope 8x', quality: 'epic', level: 80 },
+ *           { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *           { name: 'Tactical Stock', quality: 'rare', level: 75 }
+ *         ]
+ *       },
+ *       {
+ *         name: 'CombatLegend',
+ *         score: 7600,
+ *         equipments: [
+ *           { name: 'UMP45', quality: 'rare', level: 74 },
+ *           { name: 'Level 2 Vest', quality: 'common', level: 67 },
+ *           { name: 'Red Dot Sight', quality: 'common', level: 62 },
+ *           { name: 'Extended Mag', quality: 'rare', level: 70 }
+ *         ]
+ *       }
+ *     ];
+ *
+ *     // Create a TreeMultiMap for player rankings
+ *     const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
+ *       toEntryFn: ({ score, equipments }) => [score, equipments],
+ *       isMapMode: false
+ *     });
+ *
+ *     const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+ *     console.log(topPlayersEquipments); // [
+ *  //      [
+ *  //        {
+ *  //          name: 'MK14',
+ *  //          quality: 'legendary',
+ *  //          level: 92
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+ *  //        {
+ *  //          name: 'Scope 8x',
+ *  //          quality: 'epic',
+ *  //          level: 80
+ *  //        },
+ *  //        { name: 'Suppressor', quality: 'legendary', level: 88 },
+ *  //        {
+ *  //          name: 'Tactical Stock',
+ *  //          quality: 'rare',
+ *  //          level: 75
+ *  //        }
+ *  //      ],
+ *  //      [
+ *  //        { name: 'KAR98K', quality: 'legendary', level: 90 },
+ *  //        {
+ *  //          name: 'Level 3 Vest',
+ *  //          quality: 'legendary',
+ *  //          level: 85
+ *  //        },
+ *  //        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+ *  //        {
+ *  //          name: 'Suppressor',
+ *  //          quality: 'legendary',
+ *  //          level: 88
+ *  //        },
+ *  //        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+ *  //      ]
+ *  //    ]
  */
 export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR = object>
   extends RedBlackTree<K, V[], R, MK, MV[], MR>
@@ -82,7 +240,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     > = [],
     options?: TreeMultiMapOptions<K, V[], R>
   ) {
-    super([], { ...options, isMapMode: true });
+    super([], { ...options });
     if (keysNodesEntriesOrRaws) {
       this.addMany(keysNodesEntriesOrRaws);
     }
@@ -107,6 +265,7 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
       specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
+      isMapMode: this._isMapMode,
       ...options
     });
   }
@@ -115,18 +274,23 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function `createNode` overrides the method to create a new `TreeMultiMapNode` with a specified
-   * key and an empty array of values.
-   * @param {K} key - The `key` parameter in the `createNode` method represents the key of the node
-   * that will be created in the TreeMultiMap data structure.
-   * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned, with the specified key and
-   * an empty array as its value.
+   * The function `createNode` overrides the creation of a new TreeMultiMapNode with a specified key
+   * and value array.
+   * @param {K} key - The `key` parameter represents the key of the node being created in the
+   * `TreeMultiMap`.
+   * @param {V[]} value - The `value` parameter in the `createNode` method represents an array of
+   * values associated with a specific key in the TreeMultiMap data structure.
+   * @returns A new instance of `TreeMultiMapNode<K, V>` is being returned with the specified key and
+   * value. If `_isMapMode` is true, an empty array is passed as the value, otherwise the provided
+   * value is used.
    */
-  override createNode(key: K): TreeMultiMapNode<K, V> {
-    return new TreeMultiMapNode<K, V>(key, []);
+  override createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
+    return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
-  override add(node: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined): boolean;
+  override add(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): boolean;
 
   override add(key: K, value: V): boolean;
 
@@ -134,14 +298,13 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
    * Time Complexity: O(log n)
    * Space Complexity: O(log n)
    *
-   * The function `add` in TypeScript overrides the superclass method to add key-value pairs to a
-   * TreeMultiMapNode, handling different input types and scenarios.
-   * @param {K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined} keyNodeOrEntry - The `keyNodeOrEntry`
-   * parameter in the `override add` method can be either a `BTNRep` object containing a key, an array
-   * of values, and a `TreeMultiMapNode`, or just a key.
-   * @param {V} [value] - The `value` parameter in the `override add` method represents the value that
-   * you want to add to the TreeMultiMap. If the key is already present in the map, the new value will
-   * be added to the existing list of values associated with that key. If the key is not present,
+   * The function overrides the add method to handle different types of input for a TreeMultiMap data
+   * structure.
+   * @param [key] - The `key` parameter in the `override add` method represents the key of the entry to
+   * be added to the TreeMultiMap. It can be of type `K`, which is the key type of the TreeMultiMap, or
+   * it can be a TreeMultiMapNode containing the key and its
+   * @param {V[]} [values] - The `values` parameter in the `add` method represents an array of values
+   * that you want to add to the TreeMultiMap. It can contain one or more values of type `V`.
    * @returns The `add` method is returning a boolean value, which indicates whether the operation was
    * successful or not.
    */
@@ -154,27 +317,38 @@ export class TreeMultiMap<K = any, V = any, R = object, MK = any, MV = any, MR =
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const existingValues = this.get(key);
-      if (existingValues !== undefined && values !== undefined) {
-        for (const value of values) existingValues.push(value);
-        return true;
-      }
-
-      const existingNode = this.getNode(key);
-      if (this.isRealNode(existingNode)) {
-        if (existingValues === undefined) {
-          super.add(key, values);
-          return true;
-        }
-        if (values !== undefined) {
+      const _addToValues = () => {
+        const existingValues = this.get(key);
+        if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
           return true;
-        } else {
-          return false;
         }
-      } else {
-        return super.add(key, values);
+        return false;
+      };
+
+      const _addByNode = () => {
+        const existingNode = this.getNode(key);
+        if (this.isRealNode(existingNode)) {
+          const existingValues = this.get(existingNode);
+          if (existingValues === undefined) {
+            super.add(key, values);
+            return true;
+          }
+          if (values !== undefined) {
+            for (const value of values) existingValues.push(value);
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return super.add(key, values);
+        }
+      };
+
+      if (this._isMapMode) {
+        return _addByNode() || _addToValues();
       }
+      return _addToValues() || _addByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {

src/data-structures/graph/abstract-graph.ts

@@ -356,8 +356,8 @@ export abstract class AbstractGraph<
       const queue = new Queue<VO>([vertex1]);
       visited.set(vertex1, true);
       let cost = 0;
-      while (queue.size > 0) {
-        for (let i = 0; i < queue.size; i++) {
+      while (queue.length > 0) {
+        for (let i = 0; i < queue.length; i++) {
           const cur = queue.shift();
           if (cur === vertex2) {
             return cost;

src/data-structures/heap/heap.ts

@@ -185,7 +185,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   /**
    * The constructor initializes a heap data structure with optional elements and options.
    * @param elements - The `elements` parameter is an iterable object that contains the initial
@@ -416,17 +416,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
     return result;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * Convert the heap to an array.
-   * @returns An array containing the elements of the heap.
-   */
-  toArray(): E[] {
-    return [...this.elements];
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -483,7 +472,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @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: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R> {
+  filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R> {
     const filteredList = new Heap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -517,7 +506,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @returns a new instance of the `Heap` class with the mapped elements.
    */
   map<EM, RM>(
-    callback: ElementCallback<E, R, EM, Heap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/heap/max-heap.ts

@@ -61,7 +61,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MaxHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxHeap<E, R> {
     const filteredList = new MaxHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -95,7 +95,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MaxHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MaxHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/heap/min-heap.ts

@@ -49,7 +49,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MinHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinHeap<E, R> {
     const filteredList = new MinHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -83,7 +83,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MinHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MinHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/linked-list/doubly-linked-list.ts

@@ -6,86 +6,48 @@
  * @license MIT License
  */
 import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
-import { IterableElementBase } from '../base';
+import { LinearLinkedBase, LinkedListNode } from '../base/linear-base';
 
-export class DoublyLinkedListNode<E = any> {
+export class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
   /**
    * The constructor function initializes the value, next, and previous properties of an object.
    * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
    * is defined as a generic type "E".
    */
   constructor(value: E) {
+    super(value);
     this._value = value;
     this._next = undefined;
     this._prev = undefined;
   }
 
-  protected _value: E;
+  protected override _next: DoublyLinkedListNode<E> | undefined;
 
-  /**
-   * The function returns the value of a protected variable.
-   * @returns The value of the variable `_value` is being returned.
-   */
-  get value(): E {
-    return this._value;
-  }
-
-  /**
-   * The above function sets the value of a variable.
-   * @param {E} value - The parameter "value" is of type E, which means it can be any type.
-   */
-  set value(value: E) {
-    this._value = value;
-  }
-
-  protected _next: DoublyLinkedListNode<E> | undefined;
-
-  /**
-   * The "next" function returns the next node in a doubly linked list.
-   * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
-   * object or `undefined`.
-   */
-  get next(): DoublyLinkedListNode<E> | undefined {
+  override get next(): DoublyLinkedListNode<E> | undefined {
     return this._next;
   }
 
-  /**
-   * The "next" property of a DoublyLinkedListNode is set to the provided value.
-   * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-   * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-   * `DoublyLinkedListNode` object or `undefined` as its value.
-   */
-  set next(value: DoublyLinkedListNode<E> | undefined) {
+  override set next(value: DoublyLinkedListNode<E> | undefined) {
     this._next = value;
   }
 
   protected _prev: DoublyLinkedListNode<E> | undefined;
 
-  /**
-   * The `prev` function returns the previous node in a doubly linked list.
-   * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
-   * be a `DoublyLinkedListNode` object or `undefined`.
-   */
   get prev(): DoublyLinkedListNode<E> | undefined {
     return this._prev;
   }
 
-  /**
-   * The function sets the previous node of a doubly linked list node.
-   * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-   * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-   * `DoublyLinkedListNode` object or `undefined` as its value.
-   */
   set prev(value: DoublyLinkedListNode<E> | undefined) {
     this._prev = value;
   }
 }
 
 /**
- *1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  * @example
  * // text editor operation history
  *     const actions = [
@@ -159,7 +121,7 @@ export class DoublyLinkedListNode<E = any> {
  *         const initialNode = this.currentSong;
  *
  *         // Loop through the playlist twice
- *         for (let i = 0; i < this.playlist.size * 2; i++) {
+ *         for (let i = 0; i < this.playlist.length * 2; i++) {
  *           playedSongs.push(this.currentSong!.value);
  *           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
  *         }
@@ -280,7 +242,7 @@ export class DoublyLinkedListNode<E = any> {
  *         }
  *
  *         // Check capacity
- *         if (this.list.size >= this.capacity) {
+ *         if (this.list.length >= this.capacity) {
  *           // Delete the least recently used element (the tail of the linked list)
  *           const removedNode = this.list.tail;
  *           if (removedNode) {
@@ -325,9 +287,9 @@ export class DoublyLinkedListNode<E = any> {
  *         this.map.clear();
  *       }
  *
- *       // Get the current cache size
- *       get size(): number {
- *         return this.list.size;
+ *       // Get the current cache length
+ *       get length(): number {
+ *         return this.list.length;
  *       }
  *
  *       // Check if it is empty
@@ -386,7 +348,7 @@ export class DoublyLinkedListNode<E = any> {
  *
  *     console.log(cache.delete('a')); // true
  *     console.log(cache.get('a')); // undefined
- *     console.log(cache.size); // 1
+ *     console.log(cache.length); // 1
  *
  *     // Should support clearing cache
  *     cache.clear();
@@ -394,7 +356,7 @@ export class DoublyLinkedListNode<E = any> {
  *     cache.set('b', 2);
  *     cache.clear();
  *
- *     console.log(cache.size); // 0
+ *     console.log(cache.length); // 0
  *     console.log(cache.isEmpty); // true
  * @example
  * // finding lyrics by timestamp in Coldplay's "Fix You"
@@ -513,7 +475,7 @@ export class DoublyLinkedListNode<E = any> {
  *     scheduler.clear();
  *     console.log(scheduler.listProcesses()); // []
  */
-export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
+export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
   /**
    * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
    * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
@@ -531,39 +493,32 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     super(options);
     this._head = undefined;
     this._tail = undefined;
-    this._size = 0;
+    this._length = 0;
+
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+
     this.pushMany(elements);
   }
 
   protected _head: DoublyLinkedListNode<E> | undefined;
 
-  /**
-   * The `head` function returns the first node of a doubly linked list.
-   * @returns The method `getHead()` returns either a `DoublyLinkedListNode<E>` object or `undefined`.
-   */
   get head(): DoublyLinkedListNode<E> | undefined {
     return this._head;
   }
 
   protected _tail: DoublyLinkedListNode<E> | undefined;
 
-  /**
-   * The `tail` function returns the last node of a doubly linked list.
-   * @returns The `get tail()` method is returning either a `DoublyLinkedListNode<E>` object or
-   * `undefined`.
-   */
   get tail(): DoublyLinkedListNode<E> | undefined {
     return this._tail;
   }
 
-  protected _size: number;
+  protected _length: number;
 
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
-  get size(): number {
-    return this._size;
+  get length(): number {
+    return this._length;
   }
 
   /**
@@ -640,7 +595,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       this.tail!.next = newNode;
       this._tail = newNode;
     }
-    this._size++;
+    this._length++;
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
     return true;
   }
 
@@ -661,7 +617,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       this._tail = removedNode.prev;
       this.tail!.next = undefined;
     }
-    this._size--;
+    this._length--;
     return removedNode.value;
   }
 
@@ -682,7 +638,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       this._head = removedNode.next;
       this.head!.prev = undefined;
     }
-    this._size--;
+    this._length--;
     return removedNode.value;
   }
 
@@ -706,7 +662,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       this.head!.prev = newNode;
       this._head = newNode;
     }
-    this._size++;
+    this._length++;
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
     return true;
   }
 
@@ -772,7 +729,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * or the linked list is empty, it will return undefined.
    */
   at(index: number): E | undefined {
-    if (index < 0 || index >= this._size) return undefined;
+    if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -792,7 +749,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * valid range of the linked list, otherwise it returns `undefined`.
    */
   getNodeAt(index: number): DoublyLinkedListNode<E> | undefined {
-    if (index < 0 || index >= this._size) return undefined;
+    if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -822,6 +779,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean) | undefined
   ): DoublyLinkedListNode<E> | undefined {
     if (elementNodeOrPredicate === undefined) return;
+    if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
     const predicate = this._ensurePredicate(elementNodeOrPredicate);
     let current = this.head;
 
@@ -847,15 +805,15 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * `addAt` method can be either a value of type `E` or a `DoublyLinkedListNode<E>` object.
    * @returns The `addAt` method returns a boolean value. It returns `true` if the element or node was
    * successfully added at the specified index, and `false` if the index is out of bounds (less than 0
-   * or greater than the size of the list).
+   * or greater than the length of the list).
    */
   addAt(index: number, newElementOrNode: E | DoublyLinkedListNode<E>): boolean {
-    if (index < 0 || index > this._size) return false;
+    if (index < 0 || index > this._length) return false;
     if (index === 0) {
       this.unshift(newElementOrNode);
       return true;
     }
-    if (index === this._size) {
+    if (index === this._length) {
       this.push(newElementOrNode);
       return true;
     }
@@ -867,7 +825,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     newNode.next = nextNode;
     prevNode!.next = newNode;
     nextNode!.prev = newNode;
-    this._size++;
+    this._length++;
     return true;
   }
 
@@ -905,7 +863,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       if (existingNode === this.head) {
         this._head = newNode;
       }
-      this._size++;
+      this._length++;
       return true;
     }
 
@@ -944,13 +902,35 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       if (existingNode === this.tail) {
         this._tail = newNode;
       }
-      this._size++;
+      this._length++;
       return true;
     }
 
     return false;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `setAt` updates the value at a specified index in a data structure if the index
+   * exists.
+   * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
+   * data structure where you want to set a new value.
+   * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
+   * want to set at the specified index in the data structure.
+   * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
+   * is successfully updated, and `false` if the index is out of bounds.
+   */
+  setAt(index: number, value: E): boolean {
+    const node = this.getNodeAt(index);
+    if (node) {
+      node.value = value;
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -961,15 +941,18 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
    * bounds.
    */
-  deleteAt(index: number): boolean {
-    if (index < 0 || index >= this._size) return false;
+  deleteAt(index: number): E | undefined {
+    if (index < 0 || index >= this._length) return;
+    let deleted: E | undefined;
     if (index === 0) {
+      deleted = this.first;
       this.shift();
-      return true;
+      return deleted;
     }
-    if (index === this._size - 1) {
+    if (index === this._length - 1) {
+      deleted = this.last;
       this.pop();
-      return true;
+      return deleted;
     }
 
     const removedNode = this.getNodeAt(index);
@@ -977,8 +960,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     const nextNode = removedNode!.next;
     prevNode!.next = nextNode;
     nextNode!.prev = prevNode;
-    this._size--;
-    return true;
+    this._length--;
+    return removedNode?.value;
   }
 
   /**
@@ -1007,7 +990,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
         const nextNode = node.next;
         if (prevNode) prevNode.next = nextNode;
         if (nextNode) nextNode.prev = prevNode;
-        this._size--;
+        this._length--;
       }
       return true;
     }
@@ -1018,48 +1001,23 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The function checks if a variable has a size greater than zero and returns a boolean value.
+   * The function checks if a variable has a length greater than zero and returns a boolean value.
    * @returns A boolean value is being returned.
    */
   isEmpty(): boolean {
-    return this._size === 0;
+    return this._length === 0;
   }
 
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
+   * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
    */
   clear(): void {
     this._head = undefined;
     this._tail = undefined;
-    this._size = 0;
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * This function finds the index of a specified element, node, or predicate in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
-   * can be one of the following:
-   * @returns The `indexOf` method returns the index of the element in the doubly linked list that
-   * matches the provided element, node, or predicate. If no match is found, it returns -1.
-   */
-  indexOf(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number {
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let index = 0;
-    let current = this.head;
-    while (current) {
-      if (predicate(current)) {
-        return index;
-      }
-      index++;
-      current = current.next;
-    }
-    return -1;
+    this._length = 0;
   }
 
   /**
@@ -1128,40 +1086,6 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return this;
   }
 
-  /**
-   * 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[] {
-    const array: E[] = [];
-    let current = this.head;
-    while (current) {
-      array.push(current.value);
-      current = current.next;
-    }
-    return array;
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
-   * @returns The `toReversedArray()` function returns an array of type `E[]`.
-   */
-  toReversedArray(): E[] {
-    const array: E[] = [];
-    let current = this.tail;
-    while (current) {
-      array.push(current.value);
-      current = current.prev;
-    }
-    return array;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1171,8 +1095,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
    * is a copy of the original list.
    */
-  clone(): DoublyLinkedList<E, R> {
-    return new DoublyLinkedList<E, R>(this);
+  clone(): this {
+    return new DoublyLinkedList<E, R>(this, { toElementFn: this._toElementFn, maxLen: this._maxLen }) as this;
   }
 
   /**
@@ -1192,8 +1116,8 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @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, R, boolean, DoublyLinkedList<E, R>>, thisArg?: any): DoublyLinkedList<E, R> {
-    const filteredList = new DoublyLinkedList<E, R>([], { toElementFn: this.toElementFn });
+  filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): DoublyLinkedList<E, R> {
+    const filteredList = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
@@ -1225,11 +1149,11 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
    */
   map<EM, RM>(
-    callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any
   ): DoublyLinkedList<EM, RM> {
-    const mappedList = new DoublyLinkedList<EM, RM>([], { toElementFn });
+    const mappedList = new DoublyLinkedList<EM, RM>([], { toElementFn, maxLen: this._maxLen });
     let index = 0;
     for (const current of this) {
       mappedList.push(callback.call(thisArg, current, index, this));
@@ -1277,6 +1201,40 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     }
   }
 
+  /**
+   * The function returns an iterator that iterates over the elements of a data structure in reverse
+   * order.
+   */
+  protected *_getReverseIterator(): IterableIterator<E> {
+    let current = this.tail;
+
+    while (current) {
+      yield current.value;
+      current = current.prev;
+    }
+  }
+
+  /**
+   * The function returns an iterator that iterates over the nodes of a doubly linked list starting
+   * from the head.
+   */
+  protected *_getNodeIterator(): IterableIterator<DoublyLinkedListNode<E>> {
+    let current = this.head;
+
+    while (current) {
+      yield current;
+      current = current.next;
+    }
+  }
+
+  // protected *_getReverseNodeIterator(): IterableIterator<DoublyLinkedListNode<E>> {
+  //   const reversedArr = [...this._getNodeIterator()].reverse();
+  //
+  //   for (const item of reversedArr) {
+  //     yield item;
+  //   }
+  // }
+
   /**
    * The function `_isPredicate` checks if the input is a function that takes a `DoublyLinkedListNode`
    * as an argument and returns a boolean.
@@ -1325,4 +1283,30 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
 
     return (node: DoublyLinkedListNode<E>) => node.value === elementNodeOrPredicate;
   }
+
+  /**
+   * The function `_createInstance` returns a new instance of `DoublyLinkedList` with the specified
+   * options.
+   * @param [options] - The `options` parameter in the `_createInstance` method is of type
+   * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+   * configuration options when creating a new instance of the `DoublyLinkedList` class.
+   * @returns An instance of the `DoublyLinkedList` class with an empty array and the provided options
+   * is being returned, cast as the current class type.
+   */
+  protected override _createInstance(options?: DoublyLinkedListOptions<E, R>): this {
+    return new DoublyLinkedList<E, R>([], options) as this;
+  }
+
+  /**
+   * The function `_getPrevNode` returns the previous node of a given node in a doubly linked list.
+   * @param node - The parameter `node` in the `_getPrevNode` method is of type
+   * `DoublyLinkedListNode<E>`, which represents a node in a doubly linked list containing an element
+   * of type `E`.
+   * @returns The `_getPrevNode` method is returning the previous node of the input `node` in a doubly
+   * linked list. If the input node has a previous node, it will return that node. Otherwise, it will
+   * return `undefined`.
+   */
+  protected _getPrevNode(node: DoublyLinkedListNode<E>): DoublyLinkedListNode<E> | undefined {
+    return node.prev;
+  }
 }

src/data-structures/linked-list/singly-linked-list.ts

@@ -6,117 +6,76 @@
  * @license MIT License
  */
 import type { ElementCallback, SinglyLinkedListOptions } from '../../types';
-import { IterableElementBase } from '../base';
+import { LinearLinkedBase, LinkedListNode } from '../base/linear-base';
 
-export class SinglyLinkedListNode<E = any> {
+export class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
   /**
    * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
    * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
    * will be stored in the node of a linked list.
    */
   constructor(value: E) {
+    super(value);
     this._value = value;
     this._next = undefined;
   }
 
-  protected _value: E;
+  protected override _next: SinglyLinkedListNode<E> | undefined;
 
-  /**
-   * The function returns the value of a protected variable.
-   * @returns The value of the variable `_value` is being returned.
-   */
-  get value(): E {
-    return this._value;
-  }
-
-  /**
-   * The above function sets the value of a variable.
-   * @param {E} value - The parameter "value" is of type E, which means it can be any type.
-   */
-  set value(value: E) {
-    this._value = value;
-  }
-
-  protected _next: SinglyLinkedListNode<E> | undefined;
-
-  /**
-   * The `next` function returns the next node in a singly linked list.
-   * @returns The `next` property is being returned. It can be either a `SinglyLinkedListNode<E>`
-   * object or `undefined`.
-   */
-  get next(): SinglyLinkedListNode<E> | undefined {
+  override get next(): SinglyLinkedListNode<E> | undefined {
     return this._next;
   }
 
-  /**
-   * The "next" property of a SinglyLinkedListNode is set to the provided value.
-   * @param {SinglyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-   * `SinglyLinkedListNode<E> | undefined`. This means that it can accept either a
-   * `SinglyLinkedListNode` object or `undefined` as its value.
-   */
-  set next(value: SinglyLinkedListNode<E> | undefined) {
+  override set next(value: SinglyLinkedListNode<E> | undefined) {
     this._next = value;
   }
 }
 
 /**
+ * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ * 2. Bidirectional Traversal: Unlike doubly linked lists, singly linked lists can be easily traversed forwards but not backwards.
+ * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
+ * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  *
  */
-export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R, SinglyLinkedList<E, R>> {
+export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
   constructor(
     elements: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>> = [],
     options?: SinglyLinkedListOptions<E, R>
   ) {
     super(options);
+
+    if (options) {
+    }
+
     this.pushMany(elements);
   }
 
   protected _head: SinglyLinkedListNode<E> | undefined;
 
-  /**
-   * The `head` function returns the first node of a singly linked list.
-   * @returns The method is returning either a SinglyLinkedListNode object or undefined.
-   */
   get head(): SinglyLinkedListNode<E> | undefined {
     return this._head;
   }
 
   protected _tail: SinglyLinkedListNode<E> | undefined;
 
-  /**
-   * The `tail` function returns the last node of a singly linked list.
-   * @returns The method is returning either a SinglyLinkedListNode object or undefined.
-   */
   get tail(): SinglyLinkedListNode<E> | undefined {
     return this._tail;
   }
 
-  /**
-   * The above function returns the value of the first element in a linked list, or undefined if the
-   * list is empty.
-   * @returns The value of the first node in the linked list, or undefined if the linked list is empty.
-   */
   get first(): E | undefined {
     return this.head?.value;
   }
 
-  /**
-   * The function returns the value of the last element in a linked list, or undefined if the list is
-   * empty.
-   * @returns The value of the last node in the linked list, or undefined if the linked list is empty.
-   */
   get last(): E | undefined {
     return this.tail?.value;
   }
 
-  protected _size: number = 0;
+  protected _length: number = 0;
 
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
-  get size(): number {
-    return this._size;
+  get length(): number {
+    return this._length;
   }
 
   /**
@@ -154,7 +113,8 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       this.tail!.next = newNode;
       this._tail = newNode;
     }
-    this._size++;
+    this._length++;
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
     return true;
   }
 
@@ -172,7 +132,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       const value = this.head.value;
       this._head = undefined;
       this._tail = undefined;
-      this._size--;
+      this._length--;
       return value;
     }
 
@@ -183,7 +143,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     const value = this.tail!.value;
     current.next = undefined;
     this._tail = current;
-    this._size--;
+    this._length--;
     return value;
   }
 
@@ -198,7 +158,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     if (!this.head) return undefined;
     const removedNode = this.head;
     this._head = this.head.next;
-    this._size--;
+    this._length--;
     return removedNode.value;
   }
 
@@ -222,7 +182,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       newNode.next = this.head;
       this._head = newNode;
     }
-    this._size++;
+    this._length++;
     return true;
   }
 
@@ -310,7 +270,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * `undefined` if the index is out of bounds.
    */
   at(index: number): E | undefined {
-    if (index < 0 || index >= this._size) return undefined;
+    if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -365,22 +325,27 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
    * bounds.
    */
-  deleteAt(index: number): boolean {
-    if (index < 0 || index >= this._size) return false;
+  deleteAt(index: number): E | undefined {
+    if (index < 0 || index >= this._length) return;
+    let deleted: E | undefined;
     if (index === 0) {
+      deleted = this.first;
       this.shift();
-      return true;
-    }
-    if (index === this._size - 1) {
-      this.pop();
-      return true;
+      return deleted;
     }
 
-    const prevNode = this.getNodeAt(index - 1);
-    const removedNode = prevNode!.next;
-    prevNode!.next = removedNode!.next;
-    this._size--;
-    return true;
+    const targetNode = this.getNodeAt(index);
+    const prevNode = this._getPrevNode(targetNode!);
+
+    if (prevNode && targetNode) {
+      deleted = targetNode.value;
+      prevNode.next = targetNode.next;
+      if (targetNode === this.tail) this._tail = prevNode;
+      this._length--;
+      return deleted;
+    }
+
+    return;
   }
 
   /**
@@ -394,37 +359,25 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
    */
   delete(elementOrNode: E | SinglyLinkedListNode<E> | undefined): boolean {
-    if (elementOrNode === undefined) return false;
-    let value: E;
-    if (elementOrNode instanceof SinglyLinkedListNode) {
-      value = elementOrNode.value;
+    if (elementOrNode === undefined || !this.head) return false;
+
+    const node = this.isNode(elementOrNode) ? elementOrNode : this.getNode(elementOrNode);
+
+    if (!node) return false;
+
+    const prevNode = this._getPrevNode(node);
+
+    if (!prevNode) {
+      // The node is the head
+      this._head = node.next;
+      if (node === this.tail) this._tail = undefined;
     } else {
-      value = elementOrNode;
-    }
-    let current = this.head,
-      prev = undefined;
-
-    while (current) {
-      if (current.value === value) {
-        if (prev === undefined) {
-          this._head = current.next;
-          if (current === this.tail) {
-            this._tail = undefined;
-          }
-        } else {
-          prev.next = current.next;
-          if (current === this.tail) {
-            this._tail = prev;
-          }
-        }
-        this._size--;
-        return true;
-      }
-      prev = current;
-      current = current.next;
+      prevNode.next = node.next;
+      if (node === this.tail) this._tail = prevNode;
     }
 
-    return false;
+    this._length--;
+    return true;
   }
 
   /**
@@ -443,13 +396,13 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * successfully added at the specified index, and `false` if the index is out of bounds.
    */
   addAt(index: number, newElementOrNode: E | SinglyLinkedListNode<E>): boolean {
-    if (index < 0 || index > this._size) return false;
+    if (index < 0 || index > this._length) return false;
 
     if (index === 0) {
       this.unshift(newElementOrNode);
       return true;
     }
-    if (index === this._size) {
+    if (index === this._length) {
       this.push(newElementOrNode);
       return true;
     }
@@ -458,10 +411,33 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     const prevNode = this.getNodeAt(index - 1);
     newNode.next = prevNode!.next;
     prevNode!.next = newNode;
-    this._size++;
+    this._length++;
     return true;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function setAt(index, value) updates the value at a specified index in a data structure if the
+   * index exists.
+   * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
+   * data structure where you want to set a new value.
+   * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
+   * want to set at the specified index in the data structure.
+   * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
+   * is successfully updated, and `false` if the index is out of bounds (i.e., the node at that index
+   * does not exist).
+   */
+  setAt(index: number, value: E): boolean {
+    const node = this.getNodeAt(index);
+    if (node) {
+      node.value = value;
+      return true;
+    }
+    return false;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -471,7 +447,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns A boolean value indicating whether the length of the object is equal to 0.
    */
   isEmpty(): boolean {
-    return this._size === 0;
+    return this._length === 0;
   }
 
   /**
@@ -483,24 +459,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   clear(): void {
     this._head = undefined;
     this._tail = undefined;
-    this._size = 0;
-  }
-
-  /**
-   * 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[] {
-    const array: E[] = [];
-    let current = this.head;
-    while (current) {
-      array.push(current.value);
-      current = current.next;
-    }
-    return array;
+    this._length = 0;
   }
 
   /**
@@ -528,35 +487,6 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return this;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `indexOf` function in TypeScript searches for a specific element or node in a singly linked
-   * list and returns its index if found.
-   * @param {E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-   * elementNodeOrPredicate - The `elementNodeOrPredicate` parameter in the `indexOf` method can be one
-   * of the following types:
-   * @returns The `indexOf` method returns the index of the first occurrence of the element that
-   * matches the provided predicate in the singly linked list. If no matching element is found, it
-   * returns -1.
-   */
-  indexOf(elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean)): number {
-    const predicate = this._ensurePredicate(elementNodeOrPredicate);
-    let index = 0;
-    let current = this.head;
-
-    while (current) {
-      if (predicate(current)) {
-        return index;
-      }
-      index++;
-      current = current.next;
-    }
-
-    return -1;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -574,6 +504,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     elementNodeOrPredicate: E | SinglyLinkedListNode<E> | ((node: SinglyLinkedListNode<E>) => boolean) | undefined
   ): SinglyLinkedListNode<E> | undefined {
     if (elementNodeOrPredicate === undefined) return;
+    if (this.isNode(elementNodeOrPredicate)) return elementNodeOrPredicate;
     const predicate = this._ensurePredicate(elementNodeOrPredicate);
     let current = this.head;
 
@@ -607,32 +538,22 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     existingElementOrNode: E | SinglyLinkedListNode<E>,
     newElementOrNode: E | SinglyLinkedListNode<E>
   ): boolean {
-    if (!this.head) return false;
+    const existingNode = this.getNode(existingElementOrNode);
+    if (!existingNode) return false;
 
-    let existingValue: E;
-    if (this.isNode(existingElementOrNode)) {
-      existingValue = existingElementOrNode.value;
+    const prevNode = this._getPrevNode(existingNode);
+    const newNode = this._ensureNode(newElementOrNode);
+
+    if (!prevNode) {
+      // Add at the head
+      this.unshift(newNode);
     } else {
-      existingValue = existingElementOrNode;
-    }
-    if (this.head.value === existingValue) {
-      this.unshift(newElementOrNode);
-      return true;
+      prevNode.next = newNode;
+      newNode.next = existingNode;
+      this._length++;
     }
 
-    let current = this.head;
-    while (current.next) {
-      if (current.next.value === existingValue) {
-        const newNode = this._ensureNode(newElementOrNode);
-        newNode.next = current.next;
-        current.next = newNode;
-        this._size++;
-        return true;
-      }
-      current = current.next;
-    }
-
-    return false;
+    return true;
   }
 
   /**
@@ -661,13 +582,82 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
       if (existingNode === this.tail) {
         this._tail = newNode;
       }
-      this._size++;
+      this._length++;
       return true;
     }
 
     return false;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `splice` in TypeScript overrides the default behavior to remove and insert elements
+   * in a singly linked list while handling boundary cases.
+   * @param {number} start - The `start` parameter in the `splice` method indicates the index at which
+   * to start modifying the list. It specifies the position where elements will be added or removed.
+   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+   * elements can still be inserted at
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements to be
+   * inserted into the list at the specified `start` index. These elements will be inserted in place of
+   * the elements that are removed from the list. The `splice` method allows you to add new elements to
+   * the list while
+   * @returns The `splice` method is returning a `SinglyLinkedList` containing the elements that were
+   * removed from the original list during the splice operation.
+   */
+  override splice(start: number, deleteCount: number = 0, ...items: E[]): this {
+    const removedList = this._createInstance({ toElementFn: this._toElementFn, maxLen: this._maxLen });
+
+    // If `start` is out of range, perform boundary processing
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, deleteCount);
+
+    // Find the predecessor node of `start`
+    const prevNode = start === 0 ? undefined : this.getNodeAt(start - 1);
+    const startNode = prevNode ? prevNode.next : this.head;
+
+    let current = startNode;
+    for (let i = 0; i < deleteCount && current; i++) {
+      removedList.push(current.value);
+      current = current.next;
+    }
+
+    const nextNode = current;
+    let lastInsertedNode: SinglyLinkedListNode<E> | undefined = undefined;
+
+    for (const item of items) {
+      const newNode = this._ensureNode(item);
+      if (!lastInsertedNode) {
+        if (prevNode) {
+          prevNode.next = newNode;
+        } else {
+          this._head = newNode;
+        }
+      } else {
+        lastInsertedNode.next = newNode;
+      }
+      lastInsertedNode = newNode;
+    }
+
+    // Connect new node to `nextNode`
+    if (lastInsertedNode) {
+      lastInsertedNode.next = nextNode;
+    } else if (prevNode) {
+      prevNode.next = nextNode;
+    }
+
+    // Update tail node and length
+    if (!nextNode) {
+      this._tail = lastInsertedNode || prevNode;
+    }
+    this._length += items.length - removedList.length;
+
+    return removedList as this;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -703,8 +693,8 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
    * is a clone of the original list.
    */
-  clone(): SinglyLinkedList<E, R> {
-    return new SinglyLinkedList<E, R>(this, { toElementFn: this.toElementFn });
+  clone(): this {
+    return new SinglyLinkedList<E, R>(this, { toElementFn: this.toElementFn, maxLen: this._maxLen }) as this;
   }
 
   /**
@@ -724,8 +714,8 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @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, R, boolean, SinglyLinkedList<E, R>>, thisArg?: any): SinglyLinkedList<E, R> {
-    const filteredList = new SinglyLinkedList<E, R>([], { toElementFn: this.toElementFn });
+  filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): SinglyLinkedList<E, R> {
+    const filteredList = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
     let index = 0;
     for (const current of this) {
       if (callback.call(thisArg, current, index, this)) {
@@ -757,11 +747,11 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
    * @returns a new instance of the `SinglyLinkedList` class with the mapped elements.
    */
   map<EM, RM>(
-    callback: ElementCallback<E, R, EM, SinglyLinkedList<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any
   ): SinglyLinkedList<EM, RM> {
-    const mappedList = new SinglyLinkedList<EM, RM>([], { toElementFn });
+    const mappedList = new SinglyLinkedList<EM, RM>([], { toElementFn, maxLen: this._maxLen });
     let index = 0;
     for (const current of this) {
       mappedList.push(callback.call(thisArg, current, index, this));
@@ -771,6 +761,20 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     return mappedList;
   }
 
+  /**
+   * The function `_createInstance` returns a new instance of `SinglyLinkedList` with the specified
+   * options.
+   * @param [options] - The `options` parameter in the `_createInstance` method is of type
+   * `SinglyLinkedListOptions<E, R>`, which is used to configure the behavior of the `SinglyLinkedList`
+   * instance being created. It is an optional parameter, meaning it can be omitted when calling the
+   * method.
+   * @returns An instance of the `SinglyLinkedList` class with an empty array and the provided options
+   * is being returned.
+   */
+  protected override _createInstance(options?: SinglyLinkedListOptions<E, R>): this {
+    return new SinglyLinkedList<E, R>([], options) as this;
+  }
+
   /**
    * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
    */
@@ -783,6 +787,38 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
     }
   }
 
+  /**
+   * The function returns an iterator that iterates over the elements of a collection in reverse order.
+   */
+  protected *_getReverseIterator(): IterableIterator<E> {
+    const reversedArr = [...this].reverse();
+
+    for (const item of reversedArr) {
+      yield item;
+    }
+  }
+
+  /**
+   * The function `_getNodeIterator` returns an iterator that iterates over the nodes of a singly
+   * linked list.
+   */
+  protected *_getNodeIterator(): IterableIterator<SinglyLinkedListNode<E>> {
+    let current = this.head;
+
+    while (current) {
+      yield current;
+      current = current.next;
+    }
+  }
+
+  // protected *_getReverseNodeIterator(): IterableIterator<SinglyLinkedListNode<E>> {
+  //   const reversedArr = [...this._getNodeIterator()].reverse();
+  //
+  //   for (const item of reversedArr) {
+  //     yield item;
+  //   }
+  // }
+
   /**
    * The _isPredicate function in TypeScript checks if the input is a function that takes a
    * SinglyLinkedListNode as an argument and returns a boolean.
@@ -831,4 +867,24 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
 
     return (node: SinglyLinkedListNode<E>) => node.value === elementNodeOrPredicate;
   }
+
+  /**
+   * The function `_getPrevNode` returns the node before a given node in a singly linked list.
+   * @param node - The `node` parameter in the `_getPrevNode` method is a reference to a node in a
+   * singly linked list. The method is used to find the node that comes before the given node in the
+   * linked list.
+   * @returns The `_getPrevNode` method returns either the previous node of the input node in a singly
+   * linked list or `undefined` if the input node is the head of the list or if the input node is not
+   * found in the list.
+   */
+  protected _getPrevNode(node: SinglyLinkedListNode<E>): SinglyLinkedListNode<E> | undefined {
+    if (!this.head || this.head === node) return undefined;
+
+    let current = this.head;
+    while (current.next && current.next !== node) {
+      current = current.next;
+    }
+
+    return current.next === node ? current : undefined;
+  }
 }

src/data-structures/priority-queue/max-priority-queue.ts

@@ -64,10 +64,7 @@ export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
    * @returns The `filter` method is returning a new `MaxPriorityQueue` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(
-    callback: ElementCallback<E, R, boolean, MaxPriorityQueue<E, R>>,
-    thisArg?: any
-  ): MaxPriorityQueue<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxPriorityQueue<E, R> {
     const filteredPriorityQueue = new MaxPriorityQueue<E, R>([], {
       toElementFn: this.toElementFn,
       comparator: this.comparator
@@ -104,7 +101,7 @@ export class MaxPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
    * @returns a new instance of the `MaxPriorityQueue` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MaxPriorityQueue<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/priority-queue/min-priority-queue.ts

@@ -53,10 +53,7 @@ export class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
    * @returns The `filter` method is returning a new `MinPriorityQueue` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(
-    callback: ElementCallback<E, R, boolean, MinPriorityQueue<E, R>>,
-    thisArg?: any
-  ): MinPriorityQueue<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinPriorityQueue<E, R> {
     const filteredPriorityQueue = new MinPriorityQueue<E, R>([], {
       toElementFn: this.toElementFn,
       comparator: this.comparator
@@ -93,7 +90,7 @@ export class MinPriorityQueue<E = any, R = any> extends PriorityQueue<E, R> {
    * @returns a new instance of the `MinPriorityQueue` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MinPriorityQueue<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/priority-queue/priority-queue.ts

@@ -55,7 +55,7 @@ export class PriorityQueue<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, PriorityQueue<E, R>>, thisArg?: any): PriorityQueue<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): PriorityQueue<E, R> {
     const filteredPriorityQueue = new PriorityQueue<E, R>([], {
       toElementFn: this.toElementFn,
       comparator: this.comparator
@@ -92,7 +92,7 @@ export class PriorityQueue<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `PriorityQueue` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, PriorityQueue<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

src/data-structures/queue/deque.ts

@@ -6,8 +6,8 @@
  * @license MIT License
  */
 import type { DequeOptions, ElementCallback, IterableWithSizeOrLength } from '../../types';
-import { IterableElementBase } from '../base';
 import { calcMinUnitsRequired, rangeCheck } from '../../utils';
+import { LinearBase } from '../base/linear-base';
 
 /**
  * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
@@ -15,8 +15,96 @@ import { calcMinUnitsRequired, rangeCheck } from '../../utils';
  * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
  * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
+ * @example
+ * // prize roulette
+ *     class PrizeRoulette {
+ *       private deque: Deque<string>;
+ *
+ *       constructor(prizes: string[]) {
+ *         // Initialize the deque with prizes
+ *         this.deque = new Deque<string>(prizes);
+ *       }
+ *
+ *       // Rotate clockwise to the right (forward)
+ *       rotateClockwise(steps: number): void {
+ *         const n = this.deque.length;
+ *         if (n === 0) return;
+ *
+ *         for (let i = 0; i < steps; i++) {
+ *           const last = this.deque.pop(); // Remove the last element
+ *           this.deque.unshift(last!); // Add it to the front
+ *         }
+ *       }
+ *
+ *       // Rotate counterclockwise to the left (backward)
+ *       rotateCounterClockwise(steps: number): void {
+ *         const n = this.deque.length;
+ *         if (n === 0) return;
+ *
+ *         for (let i = 0; i < steps; i++) {
+ *           const first = this.deque.shift(); // Remove the first element
+ *           this.deque.push(first!); // Add it to the back
+ *         }
+ *       }
+ *
+ *       // Display the current prize at the head
+ *       display() {
+ *         return this.deque.first;
+ *       }
+ *     }
+ *
+ *     // Example usage
+ *     const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
+ *     const roulette = new PrizeRoulette(prizes);
+ *
+ *     // Display the initial state
+ *     console.log(roulette.display()); // 'Car' // Car
+ *
+ *     // Rotate clockwise by 3 steps
+ *     roulette.rotateClockwise(3);
+ *     console.log(roulette.display()); // 'Phone' // Phone
+ *
+ *     // Rotate counterclockwise by 2 steps
+ *     roulette.rotateCounterClockwise(2);
+ *     console.log(roulette.display()); // 'Headphones'
+ * @example
+ * // sliding window
+ *     // Maximum function of sliding window
+ *     function maxSlidingWindow(nums: number[], k: number): number[] {
+ *       const n = nums.length;
+ *       if (n * k === 0) return [];
+ *
+ *       const deq = new Deque<number>();
+ *       const result: number[] = [];
+ *
+ *       for (let i = 0; i < n; i++) {
+ *         // Delete indexes in the queue that are not within the window range
+ *         if (deq.length > 0 && deq.first! === i - k) {
+ *           deq.shift();
+ *         }
+ *
+ *         // Remove all indices less than the current value from the tail of the queue
+ *         while (deq.length > 0 && nums[deq.last!] < nums[i]) {
+ *           deq.pop();
+ *         }
+ *
+ *         // Add the current index to the end of the queue
+ *         deq.push(i);
+ *
+ *         // Add the maximum value of the window to the results
+ *         if (i >= k - 1) {
+ *           result.push(nums[deq.first!]);
+ *         }
+ *       }
+ *
+ *       return result;
+ *     }
+ *
+ *     const nums = [1, 3, -1, -3, 5, 3, 6, 7];
+ *     const k = 3;
+ *     console.log(maxSlidingWindow(nums, k)); // [3, 3, 5, 5, 6, 7]
  */
-export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E, R>> {
+export class Deque<E = any, R = any> extends LinearBase<E, R> {
   /**
    * The constructor initializes a Deque object with optional iterable of elements and options.
    * @param elements - An iterable object (such as an array or a Set) that contains the initial
@@ -32,9 +120,8 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     super(options);
 
     if (options) {
-      const { bucketSize, maxLen } = options;
+      const { bucketSize } = options;
       if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
-      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
 
     let _size: number;
@@ -58,96 +145,50 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
 
   protected _bucketSize: number = 1 << 12;
 
-  /**
-   * The bucketSize function returns the size of the bucket.
-   *
-   * @return The size of the bucket
-   */
   get bucketSize() {
     return this._bucketSize;
   }
 
-  protected _maxLen: number = -1;
-
-  /**
-   * The maxLen function returns the max length of the deque.
-   *
-   * @return The max length of the deque
-   */
-  get maxLen() {
-    return this._maxLen;
-  }
-
   protected _bucketFirst = 0;
 
-  /**
-   * The function returns the value of the protected variable `_bucketFirst`.
-   * @returns The value of the `_bucketFirst` property.
-   */
   get bucketFirst(): number {
     return this._bucketFirst;
   }
 
   protected _firstInBucket = 0;
 
-  /**
-   * The function returns the value of the protected variable _firstInBucket.
-   * @returns The method is returning the value of the variable `_firstInBucket`, which is of type
-   * `number`.
-   */
   get firstInBucket(): number {
     return this._firstInBucket;
   }
 
   protected _bucketLast = 0;
 
-  /**
-   * The function returns the value of the protected variable `_bucketLast`.
-   * @returns The value of the `_bucketLast` property, which is a number.
-   */
   get bucketLast(): number {
     return this._bucketLast;
   }
 
   protected _lastInBucket = 0;
 
-  /**
-   * The function returns the value of the protected variable _lastInBucket.
-   * @returns The method is returning the value of the variable `_lastInBucket`, which is of type
-   * `number`.
-   */
   get lastInBucket(): number {
     return this._lastInBucket;
   }
 
   protected _bucketCount = 0;
 
-  /**
-   * The function returns the number of buckets.
-   * @returns The number of buckets.
-   */
   get bucketCount(): number {
     return this._bucketCount;
   }
 
   protected _buckets: E[][] = [];
 
-  /**
-   * The buckets function returns the buckets property of the object.
-   * @return The buckets property
-   */
   get buckets() {
     return this._buckets;
   }
 
-  protected _size = 0;
+  protected _length = 0;
 
-  /**
-   * The size function returns the number of items in the stack.
-   * @return The number of values in the set
-   */
-  get size() {
-    return this._size;
+  get length() {
+    return this._length;
   }
 
   /**
@@ -156,7 +197,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The first element of the collection, of type E, is being returned.
    */
   get first(): E | undefined {
-    if (this._size === 0) return;
+    if (this._length === 0) return;
     return this._buckets[this._bucketFirst][this._firstInBucket];
   }
 
@@ -165,7 +206,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @return The last element in the array
    */
   get last(): E | undefined {
-    if (this._size === 0) return;
+    if (this._length === 0) return;
     return this._buckets[this._bucketLast][this._lastInBucket];
   }
 
@@ -179,7 +220,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The size of the data structure after the element has been pushed.
    */
   push(element: E): boolean {
-    if (this._size) {
+    if (this._length) {
       if (this._lastInBucket < this._bucketSize - 1) {
         this._lastInBucket += 1;
       } else if (this._bucketLast < this._bucketCount - 1) {
@@ -191,9 +232,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
       }
       if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();
     }
-    this._size += 1;
+    this._length += 1;
     this._buckets[this._bucketLast][this._lastInBucket] = element;
-    if (this._maxLen > 0 && this._size > this._maxLen) this.shift();
+    if (this._maxLen > 0 && this._length > this._maxLen) this.shift();
     return true;
   }
 
@@ -206,9 +247,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The element that was removed from the data structure is being returned.
    */
   pop(): E | undefined {
-    if (this._size === 0) return;
+    if (this._length === 0) return;
     const element = this._buckets[this._bucketLast][this._lastInBucket];
-    if (this._size !== 1) {
+    if (this._length !== 1) {
       if (this._lastInBucket > 0) {
         this._lastInBucket -= 1;
       } else if (this._bucketLast > 0) {
@@ -219,7 +260,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
         this._lastInBucket = this._bucketSize - 1;
       }
     }
-    this._size -= 1;
+    this._length -= 1;
     return element;
   }
 
@@ -233,9 +274,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * returned.
    */
   shift(): E | undefined {
-    if (this._size === 0) return;
+    if (this._length === 0) return;
     const element = this._buckets[this._bucketFirst][this._firstInBucket];
-    if (this._size !== 1) {
+    if (this._length !== 1) {
       if (this._firstInBucket < this._bucketSize - 1) {
         this._firstInBucket += 1;
       } else if (this._bucketFirst < this._bucketCount - 1) {
@@ -246,7 +287,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
         this._firstInBucket = 0;
       }
     }
-    this._size -= 1;
+    this._length -= 1;
     return element;
   }
 
@@ -261,7 +302,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The size of the data structure after the element has been added.
    */
   unshift(element: E): boolean {
-    if (this._size) {
+    if (this._length) {
       if (this._firstInBucket > 0) {
         this._firstInBucket -= 1;
       } else if (this._bucketFirst > 0) {
@@ -273,9 +314,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
       }
       if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();
     }
-    this._size += 1;
+    this._length += 1;
     this._buckets[this._bucketFirst][this._firstInBucket] = element;
-    if (this._maxLen > 0 && this._size > this._maxLen) this.pop();
+    if (this._maxLen > 0 && this._length > this._maxLen) this.pop();
     return true;
   }
 
@@ -338,7 +379,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns A boolean value indicating whether the size of the object is 0 or not.
    */
   isEmpty(): boolean {
-    return this._size === 0;
+    return this._length === 0;
   }
 
   /**
@@ -351,33 +392,10 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
   clear(): void {
     this._buckets = [new Array(this._bucketSize)];
     this._bucketCount = 1;
-    this._bucketFirst = this._bucketLast = this._size = 0;
+    this._bucketFirst = this._bucketLast = this._length = 0;
     this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
   }
 
-  /**
-   * The below function is a generator that yields elements from a collection one by one.
-   */
-  *begin(): Generator<E> {
-    let index = 0;
-    while (index < this._size) {
-      yield this.at(index);
-      index++;
-    }
-  }
-
-  /**
-   * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-   * the last element.
-   */
-  *reverseBegin(): Generator<E> {
-    let index = this._size - 1;
-    while (index >= 0) {
-      yield this.at(index);
-      index--;
-    }
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -389,7 +407,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The element at the specified position in the data structure is being returned.
    */
   at(pos: number): E {
-    rangeCheck(pos, 0, this._size - 1);
+    rangeCheck(pos, 0, this._length - 1);
     const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     return this._buckets[bucketIndex][indexInBucket]!;
   }
@@ -405,7 +423,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * position in the data structure.
    */
   setAt(pos: number, element: E): boolean {
-    rangeCheck(pos, 0, this._size - 1);
+    rangeCheck(pos, 0, this._length - 1);
     const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     this._buckets[bucketIndex][indexInBucket] = element;
     return true;
@@ -427,15 +445,15 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The size of the array after the insertion is being returned.
    */
   addAt(pos: number, element: E, num = 1): boolean {
-    const length = this._size;
+    const length = this._length;
     rangeCheck(pos, 0, length);
     if (pos === 0) {
       while (num--) this.unshift(element);
-    } else if (pos === this._size) {
+    } else if (pos === this._length) {
       while (num--) this.push(element);
     } else {
       const arr: E[] = [];
-      for (let i = pos; i < this._size; ++i) {
+      for (let i = pos; i < this._length; ++i) {
         arr.push(this.at(i));
       }
       this.cut(pos - 1, true);
@@ -465,10 +483,14 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
       this._bucketLast = bucketIndex;
       this._lastInBucket = indexInBucket;
-      this._size = pos + 1;
+      this._length = pos + 1;
       return this;
     } else {
-      const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
+      const newDeque = this._createInstance({
+        bucketSize: this._bucketSize,
+        toElementFn: this._toElementFn,
+        maxLen: this._maxLen
+      });
 
       for (let i = 0; i <= pos; i++) {
         newDeque.push(this.at(i));
@@ -478,6 +500,61 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     }
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The `splice` function in TypeScript overrides the default behavior to remove and insert elements
+   * in a Deque data structure while ensuring the starting position and delete count are within bounds.
+   * @param {number} start - The `start` parameter in the `splice` method represents the index at which
+   * to start changing the array. Items will be removed or added starting from this index.
+   * @param {number} deleteCount - The `deleteCount` parameter in the `splice` method represents the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided, it defaults to the number of elements from the `start` index to the
+   * end of the array (`
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be inserted into the deque at the specified `start` index. These elements will be inserted in
+   * place of the elements that are removed based on the `start` and `deleteCount` parameters.
+   * @returns The `splice` method is returning the array `deletedElements` which contains the elements
+   * that were removed from the Deque during the splice operation.
+   */
+  override splice(start: number, deleteCount: number = this._length - start, ...items: E[]): this {
+    // Check whether the starting position is legal
+    rangeCheck(start, 0, this._length);
+
+    // Adjust the value of deleteCount
+    if (deleteCount < 0) deleteCount = 0;
+    if (start + deleteCount > this._length) deleteCount = this._length - start;
+
+    // Save deleted elements
+    const deletedElements = this._createInstance();
+
+    // Add removed elements to the result
+    for (let i = 0; i < deleteCount; i++) {
+      deletedElements.push(this.at(start + i));
+    }
+
+    // Calculate the range that needs to be deleted
+    const elementsAfter = [];
+    for (let i = start + deleteCount; i < this._length; i++) {
+      elementsAfter.push(this.at(i));
+    }
+
+    // Adjust the length of the current Deque
+    this.cut(start - 1, true);
+
+    for (const item of items) {
+      this.push(item);
+    }
+
+    // Insert subsequent elements back
+    for (const element of elementsAfter) {
+      this.push(element);
+    }
+
+    return deletedElements;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1) or O(n)
@@ -501,12 +578,16 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
       const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
       this._bucketFirst = bucketIndex;
       this._firstInBucket = indexInBucket;
-      this._size = this._size - pos;
+      this._length = this._length - pos;
       return this;
     } else {
-      const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
+      const newDeque = this._createInstance({
+        bucketSize: this._bucketSize,
+        toElementFn: this._toElementFn,
+        maxLen: this._maxLen
+      });
       if (pos < 0) pos = 0;
-      for (let i = pos; i < this._size; i++) {
+      for (let i = pos; i < this._length; i++) {
         newDeque.push(this.at(i));
       }
 
@@ -525,22 +606,34 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * the index of the element to be deleted.
    * @returns The size of the data structure after the deletion operation is performed.
    */
-  deleteAt(pos: number): boolean {
-    rangeCheck(pos, 0, this._size - 1);
-    if (pos === 0) this.shift();
-    else if (pos === this._size - 1) this.pop();
-    else {
-      const length = this._size - 1;
-      let { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(pos);
-      for (let i = pos; i < length; ++i) {
-        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(pos + 1);
-        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
-        curBucket = nextBucket;
-        curPointer = nextPointer;
-      }
+  deleteAt(pos: number): E | undefined {
+    rangeCheck(pos, 0, this._length - 1);
+
+    let deleted: E | undefined;
+    if (pos === 0) {
+      //If it is the first element, use shift() directly
+      return this.shift();
+    } else if (pos === this._length - 1) {
+      // If it is the last element, just use pop()
+      deleted = this.last;
       this.pop();
+      return deleted;
+    } else {
+      // Delete the middle element
+      const length = this._length - 1;
+      const { bucketIndex: targetBucket, indexInBucket: targetPointer } = this._getBucketAndPosition(pos);
+      deleted = this._buckets[targetBucket][targetPointer];
+
+      for (let i = pos; i < length; i++) {
+        const { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(i);
+        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(i + 1);
+        this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
+      }
+
+      // Remove last duplicate element
+      this.pop();
+      return deleted;
     }
-    return true;
   }
 
   /**
@@ -554,7 +647,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The size of the data structure after the element has been deleted.
    */
   delete(element: E): boolean {
-    const size = this._size;
+    const size = this._length;
     if (size === 0) return false;
     let i = 0;
     let index = 0;
@@ -570,6 +663,43 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     return true;
   }
 
+  // /**
+  //  * Time Complexity: O(n)
+  //  * Space Complexity: O(1)
+  //  *
+  //  * This function overrides the indexOf method to search for an element within a custom data
+  //  * structure.
+  //  * @param {E} searchElement - The `searchElement` parameter is the element that you are searching for
+  //  * within the data structure. The `indexOf` method will return the index of the first occurrence of
+  //  * this element within the data structure.
+  //  * @param {number} [fromIndex=0] - The `fromIndex` parameter in the `indexOf` method specifies the
+  //  * index at which to start searching for the `searchElement` within the data structure. If provided,
+  //  * the search will begin at this index instead of the beginning of the data structure.
+  //  * @returns The indexOf method is returning the index of the searchElement if it is found in the data
+  //  * structure, or -1 if the searchElement is not found.
+  //  */
+  // override indexOf(searchElement: E, fromIndex: number = 0): number {
+  //   let index = fromIndex;
+  //   let bucketIndex = this._bucketFirst;
+  //   let indexInBucket = this._firstInBucket + fromIndex;
+  //
+  //   for (let i = 0; i < this._length; i++) {
+  //     if (this._buckets[bucketIndex][indexInBucket] === searchElement) {
+  //       return index;
+  //     }
+  //     index++;
+  //     indexInBucket++;
+  //     if (indexInBucket >= this._bucketSize) {
+  //       bucketIndex++;
+  //       indexInBucket = 0;
+  //     }
+  //     if (bucketIndex >= this._bucketCount) {
+  //       bucketIndex = 0;
+  //     }
+  //   }
+  //   return -1;
+  // }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -600,12 +730,12 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The size of the modified array is being returned.
    */
   unique(): this {
-    if (this._size <= 1) {
+    if (this._length <= 1) {
       return this;
     }
     let index = 1;
     let prev = this.at(0);
-    for (let i = 1; i < this._size; ++i) {
+    for (let i = 1; i < this._length; ++i) {
       const cur = this.at(i);
       if (cur !== prev) {
         prev = cur;
@@ -616,28 +746,6 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     return this;
   }
 
-  /**
-   * Time Complexity: O(n log n)
-   * Space Complexity: O(n)
-   *
-   * The `sort` function sorts the elements in a data structure using a provided comparator function.
-   * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
-   * `y` of type `E` and returns a number. The comparator function is used to determine the order of
-   * the elements in the sorted array.
-   * @returns Deque<E>
-   */
-  sort(comparator?: (x: E, y: E) => number): this {
-    const arr: E[] = [];
-    for (let i = 0; i < this._size; ++i) {
-      arr.push(this.at(i));
-    }
-    arr.sort(comparator);
-    for (let i = 0; i < this._size; ++i) {
-      this.setAt(i, arr[i]);
-    }
-    return this;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -645,10 +753,10 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * The `shrinkToFit` function reorganizes the elements in an array-like data structure to minimize
    * memory usage.
    * @returns Nothing is being returned. The function is using the `return` statement to exit early if
-   * `this._size` is 0, but it does not return any value.
+   * `this._length` is 0, but it does not return any value.
    */
   shrinkToFit(): void {
-    if (this._size === 0) return;
+    if (this._length === 0) return;
     const newBuckets = [];
     if (this._bucketFirst === this._bucketLast) return;
     else if (this._bucketFirst < this._bucketLast) {
@@ -668,37 +776,6 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     this._buckets = newBuckets;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function "indexOf" returns the index of the first occurrence of a given element in an array,
-   * or -1 if the element is not found.
-   * @param {E} element - The "element" parameter represents the element that you want to find the
-   * index of in the data structure.
-   * @returns The indexOf function returns the index of the first occurrence of the specified element
-   * in the data structure. If the element is not found, it returns -1.
-   */
-  indexOf(element: E): number {
-    for (let i = 0; i < this._size; ++i) {
-      if (this.at(i) === element) {
-        return i;
-      }
-    }
-    return -1;
-  }
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `toArray` function converts the elements of a data structure into an array.
-   * @returns The `toArray()` method is returning an array of elements of type `E`.
-   */
-  toArray(): E[] {
-    return [...this];
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -708,8 +785,12 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
    * elements as the original deque (`this`) and the same bucket size.
    */
-  clone(): Deque<E, R> {
-    return new Deque<E, R>(this, { bucketSize: this.bucketSize, toElementFn: this.toElementFn });
+  clone(): this {
+    return new Deque<E, R>(this, {
+      bucketSize: this.bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    }) as this;
   }
 
   /**
@@ -728,8 +809,12 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * @returns The `filter` method is returning a new `Deque` object that contains the elements that
    * satisfy the given predicate function.
    */
-  filter(predicate: ElementCallback<E, R, boolean, Deque<E, R>>, thisArg?: any): Deque<E, R> {
-    const newDeque = new Deque<E, R>([], { bucketSize: this._bucketSize, toElementFn: this.toElementFn });
+  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Deque<E, R> {
+    const newDeque = this._createInstance({
+      bucketSize: this._bucketSize,
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen
+    });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -758,12 +843,8 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * value of
    * @returns a new Deque object with elements of type EM and raw elements of type RM.
    */
-  map<EM, RM>(
-    callback: ElementCallback<E, R, EM, Deque<E, R>>,
-    toElementFn?: (rawElement: RM) => EM,
-    thisArg?: any
-  ): Deque<EM, RM> {
-    const newDeque = new Deque<EM, RM>([], { bucketSize: this._bucketSize, toElementFn });
+  map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Deque<EM, RM> {
+    const newDeque = new Deque<EM, RM>([], { bucketSize: this._bucketSize, toElementFn, maxLen: this._maxLen });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));
@@ -780,7 +861,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * object to be iterated over using a for...of loop.
    */
   protected *_getIterator(): IterableIterator<E> {
-    for (let i = 0; i < this._size; ++i) {
+    for (let i = 0; i < this._length; ++i) {
       yield this.at(i);
     }
   }
@@ -843,4 +924,26 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
 
     return { bucketIndex, indexInBucket };
   }
+
+  /**
+   * The function `_createInstance` returns a new instance of the `Deque` class with the specified
+   * options.
+   * @param [options] - The `options` parameter in the `_createInstance` method is of type
+   * `DequeOptions<E, R>`, which is an optional parameter that allows you to pass additional
+   * configuration options when creating a new instance of the `Deque` class.
+   * @returns An instance of the `Deque` class with an empty array and the provided options, casted as
+   * `this`.
+   */
+  protected override _createInstance(options?: DequeOptions<E, R>): this {
+    return new Deque<E, R>([], options) as this;
+  }
+
+  /**
+   * This function returns an iterator that iterates over elements in reverse order.
+   */
+  protected *_getReverseIterator(): IterableIterator<E> {
+    for (let i = this._length - 1; i > -1; i--) {
+      yield this.at(i);
+    }
+  }
 }

src/data-structures/queue/queue.ts

@@ -4,8 +4,8 @@
  * @class
  */
 import type { ElementCallback, QueueOptions } from '../../types';
-import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
+import { LinearBase } from '../base/linear-base';
 
 /**
  * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
@@ -16,7 +16,7 @@ import { SinglyLinkedList } from '../linked-list';
  * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
-export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
+export class Queue<E = any, R = any> extends LinearBase<E, R> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: QueueOptions<E, R>) {
     super(options);
 
@@ -30,42 +30,40 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
 
   protected _elements: E[] = [];
 
-  /**
-   * The elements function returns the elements of this set.
-   * @return An array of the elements in the stack
-   */
   get elements(): E[] {
     return this._elements;
   }
 
   protected _offset: number = 0;
 
-  /**
-   * The offset function returns the offset of the current page.
-   * @return The value of the protected variable _offset
-   */
   get offset(): number {
     return this._offset;
   }
 
-  /**
-   * The size function returns the number of elements in an array.
-   * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
-   */
-  get size(): number {
+  get length(): number {
     return this.elements.length - this.offset;
   }
 
+  protected _autoCompactRatio: number = 0.5;
+
+  get autoCompactRatio(): number {
+    return this._autoCompactRatio;
+  }
+
+  set autoCompactRatio(v: number) {
+    this._autoCompactRatio = v;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
    * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
-   * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
+   * the `_offset` index. If the data structure is empty (length is 0), it returns `undefined`.
    */
   get first(): E | undefined {
-    return this.size > 0 ? this.elements[this.offset] : undefined;
+    return this.length > 0 ? this.elements[this.offset] : undefined;
   }
 
   /**
@@ -77,26 +75,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * array is empty, it returns `undefined`.
    */
   get last(): E | undefined {
-    return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
-  }
-
-  protected _autoCompactRatio: number = 0.5;
-
-  /**
-   * This function returns the value of the autoCompactRatio property.
-   * @returns The `autoCompactRatio` property of the object, which is a number.
-   */
-  get autoCompactRatio(): number {
-    return this._autoCompactRatio;
-  }
-
-  /**
-   * The above function sets the autoCompactRatio property to a specified number in TypeScript.
-   * @param {number} v - The parameter `v` represents the value that will be assigned to the
-   * `_autoCompactRatio` property.
-   */
-  set autoCompactRatio(v: number) {
-    this._autoCompactRatio = v;
+    return this.length > 0 ? this.elements[this.elements.length - 1] : undefined;
   }
 
   /**
@@ -123,6 +102,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    */
   push(element: E): boolean {
     this.elements.push(element);
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
     return true;
   }
 
@@ -155,7 +135,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
    */
   shift(): E | undefined {
-    if (this.size === 0) return undefined;
+    if (this.length === 0) return undefined;
 
     const first = this.first;
     this._offset += 1;
@@ -174,7 +154,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    */
   delete(element: E): boolean {
     const index = this.elements.indexOf(element);
-    return this.deleteAt(index);
+    return !!this.deleteAt(index);
   }
 
   /**
@@ -185,9 +165,10 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * @param {number} index - Determine the index of the element to be deleted
    * @return A boolean value
    */
-  deleteAt(index: number): boolean {
-    const spliced = this.elements.splice(index, 1);
-    return spliced.length === 1;
+  deleteAt(index: number): E | undefined {
+    const deleted = this.elements[index];
+    this.elements.splice(index, 1);
+    return deleted;
   }
 
   /**
@@ -206,25 +187,68 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
   }
 
   /**
-   * Time Complexity: O(1)
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * The function checks if a data structure is empty by comparing its size to zero.
-   * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+   * The `reverse` function in TypeScript reverses the elements of an array starting from a specified
+   * offset.
+   * @returns The `reverse()` method is returning the modified object itself (`this`) after reversing
+   * the elements in the array and resetting the offset to 0.
    */
-  isEmpty(): boolean {
-    return this.size === 0;
+  reverse(): this {
+    this._elements = this.elements.slice(this.offset).reverse();
+    this._offset = 0;
+    return this;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function `addAt` inserts a new element at a specified index in an array, returning true if
+   * successful and false if the index is out of bounds.
+   * @param {number} index - The `index` parameter represents the position at which the `newElement`
+   * should be added in the array.
+   * @param {E} newElement - The `newElement` parameter represents the element that you want to insert
+   * into the array at the specified index.
+   * @returns The `addAt` method returns a boolean value - `true` if the new element was successfully
+   * added at the specified index, and `false` if the index is out of bounds (less than 0 or greater
+   * than the length of the array).
+   */
+  addAt(index: number, newElement: E): boolean {
+    if (index < 0 || index > this.length) return false;
+    this._elements.splice(this.offset + index, 0, newElement);
+    return true;
   }
 
   /**
    * Time Complexity: O(1)
-   * Space Complexity: O(n)
+   * Space Complexity: O(1)
    *
-   * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
-   * @returns An array of type E is being returned.
+   * The function `setAt` updates an element at a specified index in an array-like data structure.
+   * @param {number} index - The `index` parameter is a number that represents the position in the
+   * array where the new element will be set.
+   * @param {E} newElement - The `newElement` parameter represents the new value that you want to set
+   * at the specified index in the array.
+   * @returns The `setAt` method returns a boolean value - `true` if the element was successfully set
+   * at the specified index, and `false` if the index is out of bounds (less than 0 or greater than the
+   * length of the array).
    */
-  toArray(): E[] {
-    return this.elements.slice(this.offset);
+  setAt(index: number, newElement: E): boolean {
+    if (index < 0 || index > this.length) return false;
+    this._elements[this.offset + index] = newElement;
+    return true;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The function checks if a data structure is empty by comparing its length to zero.
+   * @returns {boolean} A boolean value indicating whether the length of the object is 0 or not.
+   */
+  isEmpty(): boolean {
+    return this.length === 0;
   }
 
   /**
@@ -252,6 +276,40 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     return true;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function overrides the splice method to remove and insert elements in a queue-like data
+   * structure.
+   * @param {number} start - The `start` parameter in the `splice` method specifies the index at which
+   * to start changing the array. Items will be added or removed starting from this index.
+   * @param {number} [deleteCount=0] - The `deleteCount` parameter in the `splice` method specifies the
+   * number of elements to remove from the array starting at the specified `start` index. If
+   * `deleteCount` is not provided, it defaults to 0, meaning no elements will be removed but new
+   * elements can still be inserted at
+   * @param {E[]} items - The `items` parameter in the `splice` method represents the elements that
+   * will be added to the array at the specified `start` index. These elements will replace the
+   * existing elements starting from the `start` index for the `deleteCount` number of elements.
+   * @returns The `splice` method is returning the `removedQueue`, which is an instance of the same
+   * class as the original object.
+   */
+  override splice(start: number, deleteCount: number = 0, ...items: E[]): this {
+    const removedQueue = this._createInstance();
+
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+
+    const globalStartIndex = this.offset + start;
+
+    const removedElements = this._elements.splice(globalStartIndex, deleteCount, ...items);
+    removedQueue.pushMany(removedElements);
+
+    this.compact();
+
+    return removedQueue;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -259,8 +317,8 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * The `clone()` function returns a new Queue object with the same elements as the original Queue.
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
    */
-  clone(): Queue<E, R> {
-    return new Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn });
+  clone(): this {
+    return new Queue(this.elements.slice(this.offset), { toElementFn: this.toElementFn, maxLen: this._maxLen }) as this;
   }
 
   /**
@@ -279,8 +337,12 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * @returns The `filter` method is returning a new `Queue` object that contains the elements that
    * satisfy the given predicate function.
    */
-  filter(predicate: ElementCallback<E, R, boolean, Queue<E, R>>, thisArg?: any): Queue<E, R> {
-    const newDeque = new Queue<E, R>([], { toElementFn: this.toElementFn });
+  filter(predicate: ElementCallback<E, R, boolean>, thisArg?: any): Queue<E, R> {
+    const newDeque = this._createInstance({
+      toElementFn: this._toElementFn,
+      autoCompactRatio: this._autoCompactRatio,
+      maxLen: this._maxLen
+    });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -309,12 +371,12 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    * @returns A new Queue object containing elements of type EM, which are the result of applying the
    * callback function to each element in the original Queue object.
    */
-  map<EM, RM>(
-    callback: ElementCallback<E, R, EM, Queue<E, R>>,
-    toElementFn?: (rawElement: RM) => EM,
-    thisArg?: any
-  ): Queue<EM, RM> {
-    const newDeque = new Queue<EM, RM>([], { toElementFn });
+  map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): Queue<EM, RM> {
+    const newDeque = new Queue<EM, RM>([], {
+      toElementFn,
+      autoCompactRatio: this._autoCompactRatio,
+      maxLen: this._maxLen
+    });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));
@@ -334,6 +396,30 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
       yield item;
     }
   }
+
+  /**
+   * The function `_createInstance` returns a new instance of the `Queue` class with the specified
+   * options.
+   * @param [options] - The `options` parameter in the `_createInstance` method is of type
+   * `QueueOptions<E, R>`, which is used to configure the behavior of the queue being created. It
+   * allows you to specify settings or properties that can influence how the queue operates.
+   * @returns An instance of the `Queue` class with an empty array and the provided options is being
+   * returned.
+   */
+  protected override _createInstance(options?: QueueOptions<E, R>): this {
+    return new Queue<E, R>([], options) as this;
+  }
+
+  /**
+   * The function `_getReverseIterator` returns an iterator that iterates over elements in reverse
+   * order.
+   */
+  protected *_getReverseIterator(): IterableIterator<E> {
+    for (let i = this.length - 1; i >= 0; i--) {
+      const cur = this.at(i); // `at()` handles the offset.
+      if (cur !== undefined) yield cur;
+    }
+  }
 }
 
 /**
@@ -351,7 +437,7 @@ export class LinkedListQueue<E = any, R = any> extends SinglyLinkedList<E, R> {
    * @returns The `clone()` method is returning a new instance of `LinkedListQueue` with the same
    * values as the original `LinkedListQueue`.
    */
-  override clone(): LinkedListQueue<E, R> {
-    return new LinkedListQueue<E, R>(this, { toElementFn: this.toElementFn });
+  override clone(): this {
+    return new LinkedListQueue<E, R>(this, { toElementFn: this.toElementFn, maxLen: this._maxLen }) as this;
   }
 }

src/data-structures/stack/stack.ts

@@ -16,7 +16,7 @@ import { IterableElementBase } from '../base';
  * 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.
  */
-export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E, R>> {
+export class Stack<E = any, R = any> extends IterableElementBase<E, R> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: StackOptions<E, R>) {
     super(options);
     this.pushMany(elements);
@@ -153,17 +153,6 @@ export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E,
     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(): E[] {
-    return this.elements.slice();
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -201,7 +190,7 @@ export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E,
    * @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> {
     const newStack = new Stack<E, R>([], { toElementFn: this.toElementFn });
     let index = 0;
     for (const el of this) {
@@ -230,11 +219,7 @@ export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E,
    * 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> {
     const newStack = new Stack<EM, RM>([], { toElementFn });
     let index = 0;
     for (const el of this) {

src/data-structures/trie/trie.ts

@@ -170,7 +170,7 @@ export class TrieNode {
  *     const subnet = ip.split('.').slice(0, 3).join('.');
  *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
-export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
+export class Trie<R = any> extends IterableElementBase<string, R> {
   /**
    * The constructor initializes a Trie data structure with optional options and words provided as
    * input.
@@ -545,7 +545,7 @@ export 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> {
     const results = new Trie<R>([], { toElementFn: this.toElementFn, caseSensitive: this.caseSensitive });
     let index = 0;
     for (const word of this) {
@@ -576,7 +576,7 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
    * @returns a new Trie object.
    */
   map<RM>(
-    callback: ElementCallback<string, R, string, Trie<R>>,
+    callback: ElementCallback<string, R, string>,
     toElementFn?: (rawElement: RM) => string,
     thisArg?: any
   ): Trie<RM> {
@@ -609,6 +609,10 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
     yield* _dfs(this.root, '');
   }
 
+  protected get _total() {
+    return this._size;
+  }
+
   /**
    * Time Complexity: O(l), where l is the length of the input string.
    * Space Complexity: O(1) - Constant space.

src/types/data-structures/base/base.ts

@@ -1,25 +1,34 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
+import { LinearBase } from '../../../data-structures/base/linear-base';
 
-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 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,
-  container: IterableEntryBase<K, V>
+  original: IterableEntryBase<K, V>
 ) => R;
-export type ReduceElementCallback<E, R, RT, C> = (
+
+export type ReduceElementCallback<E, R, RT = E> = (
   accumulator: RT,
   element: E,
   index: number,
-  container: IterableElementBase<E, R, C>
+  original: IterableElementBase<E, R>
 ) => RT;
 
-// export type IterableEntryBaseOptions<K, V, R> = {
-//   toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
-// };
+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;
+};

src/types/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -1,3 +1,3 @@
 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> & {}

src/types/data-structures/binary-tree/tree-multi-map.ts

@@ -1,3 +1,3 @@
 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> & {}

src/types/data-structures/linked-list/doubly-linked-list.ts

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

src/types/data-structures/linked-list/singly-linked-list.ts

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

src/types/data-structures/queue/deque.ts

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

src/types/data-structures/queue/queue.ts

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

test/integration/all-in-one.test.ts

@@ -23,7 +23,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

test/integration/avl-tree.test.ts

@@ -40,7 +40,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) tree.dfs(node => (subTreeSum += node.key), 'IN', 15);
+    if (node15) tree.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

test/integration/bst.test.ts

@@ -37,7 +37,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) bst.dfs(node => (subTreeSum += node.key), 'IN', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'IN', false, 15);
     expect(subTreeSum).toBe(45);
 
     let lesserSum = 0;
@@ -236,7 +236,7 @@ describe('Individual package BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'IN', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'IN', false, node15);
     expect(subTreeSum).toBe(45);
 
     let lesserSum = 0;

test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -570,3 +570,171 @@ describe('AVLTreeMultiMap iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toEqual(['c']);
   });
 });
+
+describe('classic use', () => {
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('players ranked by score with their equipment', () => {
+    type Equipment = {
+      name: string; // Equipment name
+      quality: 'legendary' | 'epic' | 'rare' | 'common';
+      level: number;
+    };
+
+    type Player = {
+      name: string;
+      score: number;
+      equipments: Equipment[];
+    };
+
+    // Mock player data with their scores and equipment
+    const players: Player[] = [
+      {
+        name: 'DragonSlayer',
+        score: 8750,
+        equipments: [
+          { name: 'AWM', quality: 'legendary', level: 85 },
+          { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+          { name: 'Compensator', quality: 'epic', level: 78 },
+          { name: 'Vertical Grip', quality: 'rare', level: 72 }
+        ]
+      },
+      {
+        name: 'ShadowNinja',
+        score: 7200,
+        equipments: [
+          { name: 'M416', quality: 'epic', level: 75 },
+          { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+          { name: 'Red Dot Sight', quality: 'common', level: 65 },
+          { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'RuneMaster',
+        score: 9100,
+        equipments: [
+          { name: 'KAR98K', quality: 'legendary', level: 90 },
+          { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+          { name: 'Holographic Sight', quality: 'epic', level: 82 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+        ]
+      },
+      {
+        name: 'BattleKing',
+        score: 8500,
+        equipments: [
+          { name: 'AUG', quality: 'epic', level: 82 },
+          { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+          { name: 'Extended Mag', quality: 'common', level: 70 },
+          { name: 'Tactical Stock', quality: 'rare', level: 76 }
+        ]
+      },
+      {
+        name: 'SniperElite',
+        score: 7800,
+        equipments: [
+          { name: 'M24', quality: 'legendary', level: 88 },
+          { name: 'Compensator', quality: 'epic', level: 80 },
+          { name: 'Scope 8x', quality: 'legendary', level: 85 },
+          { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'RushMaster',
+        score: 7500,
+        equipments: [
+          { name: 'Vector', quality: 'rare', level: 72 },
+          { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+          { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+          { name: 'Laser Sight', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'GhostWarrior',
+        score: 8200,
+        equipments: [
+          { name: 'SCAR-L', quality: 'epic', level: 78 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+          { name: 'Holographic Sight', quality: 'epic', level: 75 },
+          { name: 'Suppressor', quality: 'rare', level: 72 },
+          { name: 'Vertical Grip', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'DeathDealer',
+        score: 7300,
+        equipments: [
+          { name: 'SKS', quality: 'epic', level: 76 },
+          { name: 'Holographic Sight', quality: 'rare', level: 68 },
+          { name: 'Extended Mag', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'StormRider',
+        score: 8900,
+        equipments: [
+          { name: 'MK14', quality: 'legendary', level: 92 },
+          { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+          { name: 'Scope 8x', quality: 'epic', level: 80 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Tactical Stock', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'CombatLegend',
+        score: 7600,
+        equipments: [
+          { name: 'UMP45', quality: 'rare', level: 74 },
+          { name: 'Level 2 Vest', quality: 'common', level: 67 },
+          { name: 'Red Dot Sight', quality: 'common', level: 62 },
+          { name: 'Extended Mag', quality: 'rare', level: 70 }
+        ]
+      }
+    ];
+
+    // Create a TreeMultiMap for player rankings
+    const playerRankings = new AVLTreeMultiMap<number, Equipment, Player>(players, {
+      toEntryFn: ({ score, equipments }) => [score, equipments],
+      isMapMode: false
+    });
+
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    expect(topPlayersEquipments).toEqual([
+      [
+        {
+          name: 'MK14',
+          quality: 'legendary',
+          level: 92
+        },
+        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+        {
+          name: 'Scope 8x',
+          quality: 'epic',
+          level: 80
+        },
+        { name: 'Suppressor', quality: 'legendary', level: 88 },
+        {
+          name: 'Tactical Stock',
+          quality: 'rare',
+          level: 75
+        }
+      ],
+      [
+        { name: 'KAR98K', quality: 'legendary', level: 90 },
+        {
+          name: 'Level 3 Vest',
+          quality: 'legendary',
+          level: 85
+        },
+        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+        {
+          name: 'Suppressor',
+          quality: 'legendary',
+          level: 88
+        },
+        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+      ]
+    ]);
+  });
+});

test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -546,6 +546,7 @@ describe('AVLTree iterative methods not map mode', () => {
 describe('classic use', () => {
   // Test case for finding elements in a given range
   it('@example Find elements in a range', () => {
+    // In interval queries, AVL trees, with their strictly balanced structure and lower height, offer better query efficiency, making them ideal for frequent and high-performance interval queries. In contrast, Red-Black trees, with lower update costs, are more suitable for scenarios involving frequent insertions and deletions where the requirements for interval queries are less demanding.
     type Datum = { timestamp: Date; temperature: number };
     // Fixed dataset of CPU temperature readings
     const cpuData: Datum[] = [
@@ -594,18 +595,18 @@ describe('classic use', () => {
       temperature: cpuTemperatureTree.get(node ? node.key : undefined)
     }));
 
-    expect(rangeResults).toEqual( [
-            { minute: 5, temperature: 59.4 },
-            { minute: 6, temperature: 60.1 },
-            { minute: 7, temperature: 61.3 },
-            { minute: 8, temperature: 62 },
-            { minute: 9, temperature: 63.5 },
-            { minute: 10, temperature: 64 },
-            { minute: 11, temperature: 62.8 },
-            { minute: 12, temperature: 61.5 },
-            { minute: 13, temperature: 60.2 },
-            { minute: 14, temperature: 59.8 },
-            { minute: 15, temperature: 58.6 }
-          ]);
+    expect(rangeResults).toEqual([
+      { minute: 5, temperature: 59.4 },
+      { minute: 6, temperature: 60.1 },
+      { minute: 7, temperature: 61.3 },
+      { minute: 8, temperature: 62 },
+      { minute: 9, temperature: 63.5 },
+      { minute: 10, temperature: 64 },
+      { minute: 11, temperature: 62.8 },
+      { minute: 12, temperature: 61.5 },
+      { minute: 13, temperature: 60.2 },
+      { minute: 14, temperature: 59.8 },
+      { minute: 15, temperature: 58.6 }
+    ]);
   });
 });

test/unit/data-structures/binary-tree/tree-multi-map.test.ts

@@ -837,11 +837,169 @@ describe('real world data', () => {
 });
 
 describe('classic use', () => {
-  // Test case for finding elements in a given range
-  it('@example Find elements in a range', () => {
-    const tmm = new TreeMultiMap<number>([10, 5, 15, 3, 7, 12, 18]);
-    expect(tmm.search(new Range(5, 10))).toEqual([5, 7, 10]);
-    expect(tmm.search(new Range(4, 12))).toEqual([5, 7, 10, 12]);
-    expect(tmm.search(new Range(15, 20))).toEqual([15, 18]);
+  // Test suite for TreeMultiMap with player ranking and equipment
+  it('@example players ranked by score with their equipment', () => {
+    type Equipment = {
+      name: string; // Equipment name
+      quality: 'legendary' | 'epic' | 'rare' | 'common';
+      level: number;
+    };
+
+    type Player = {
+      name: string;
+      score: number;
+      equipments: Equipment[];
+    };
+
+    // Mock player data with their scores and equipment
+    const players: Player[] = [
+      {
+        name: 'DragonSlayer',
+        score: 8750,
+        equipments: [
+          { name: 'AWM', quality: 'legendary', level: 85 },
+          { name: 'Level 3 Helmet', quality: 'epic', level: 80 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 75 },
+          { name: 'Compensator', quality: 'epic', level: 78 },
+          { name: 'Vertical Grip', quality: 'rare', level: 72 }
+        ]
+      },
+      {
+        name: 'ShadowNinja',
+        score: 7200,
+        equipments: [
+          { name: 'M416', quality: 'epic', level: 75 },
+          { name: 'Ghillie Suit', quality: 'rare', level: 70 },
+          { name: 'Red Dot Sight', quality: 'common', level: 65 },
+          { name: 'Extended QuickDraw Mag', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'RuneMaster',
+        score: 9100,
+        equipments: [
+          { name: 'KAR98K', quality: 'legendary', level: 90 },
+          { name: 'Level 3 Vest', quality: 'legendary', level: 85 },
+          { name: 'Holographic Sight', quality: 'epic', level: 82 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+        ]
+      },
+      {
+        name: 'BattleKing',
+        score: 8500,
+        equipments: [
+          { name: 'AUG', quality: 'epic', level: 82 },
+          { name: 'Red Dot Sight', quality: 'rare', level: 75 },
+          { name: 'Extended Mag', quality: 'common', level: 70 },
+          { name: 'Tactical Stock', quality: 'rare', level: 76 }
+        ]
+      },
+      {
+        name: 'SniperElite',
+        score: 7800,
+        equipments: [
+          { name: 'M24', quality: 'legendary', level: 88 },
+          { name: 'Compensator', quality: 'epic', level: 80 },
+          { name: 'Scope 8x', quality: 'legendary', level: 85 },
+          { name: 'Level 2 Helmet', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'RushMaster',
+        score: 7500,
+        equipments: [
+          { name: 'Vector', quality: 'rare', level: 72 },
+          { name: 'Level 2 Helmet', quality: 'common', level: 65 },
+          { name: 'Quickdraw Mag', quality: 'common', level: 60 },
+          { name: 'Laser Sight', quality: 'rare', level: 68 }
+        ]
+      },
+      {
+        name: 'GhostWarrior',
+        score: 8200,
+        equipments: [
+          { name: 'SCAR-L', quality: 'epic', level: 78 },
+          { name: 'Extended Quickdraw Mag', quality: 'rare', level: 70 },
+          { name: 'Holographic Sight', quality: 'epic', level: 75 },
+          { name: 'Suppressor', quality: 'rare', level: 72 },
+          { name: 'Vertical Grip', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'DeathDealer',
+        score: 7300,
+        equipments: [
+          { name: 'SKS', quality: 'epic', level: 76 },
+          { name: 'Holographic Sight', quality: 'rare', level: 68 },
+          { name: 'Extended Mag', quality: 'common', level: 65 }
+        ]
+      },
+      {
+        name: 'StormRider',
+        score: 8900,
+        equipments: [
+          { name: 'MK14', quality: 'legendary', level: 92 },
+          { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+          { name: 'Scope 8x', quality: 'epic', level: 80 },
+          { name: 'Suppressor', quality: 'legendary', level: 88 },
+          { name: 'Tactical Stock', quality: 'rare', level: 75 }
+        ]
+      },
+      {
+        name: 'CombatLegend',
+        score: 7600,
+        equipments: [
+          { name: 'UMP45', quality: 'rare', level: 74 },
+          { name: 'Level 2 Vest', quality: 'common', level: 67 },
+          { name: 'Red Dot Sight', quality: 'common', level: 62 },
+          { name: 'Extended Mag', quality: 'rare', level: 70 }
+        ]
+      }
+    ];
+
+    // Create a TreeMultiMap for player rankings
+    const playerRankings = new TreeMultiMap<number, Equipment, Player>(players, {
+      toEntryFn: ({ score, equipments }) => [score, equipments],
+      isMapMode: false
+    });
+
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    expect(topPlayersEquipments).toEqual([
+      [
+        {
+          name: 'MK14',
+          quality: 'legendary',
+          level: 92
+        },
+        { name: 'Level 3 Backpack', quality: 'legendary', level: 85 },
+        {
+          name: 'Scope 8x',
+          quality: 'epic',
+          level: 80
+        },
+        { name: 'Suppressor', quality: 'legendary', level: 88 },
+        {
+          name: 'Tactical Stock',
+          quality: 'rare',
+          level: 75
+        }
+      ],
+      [
+        { name: 'KAR98K', quality: 'legendary', level: 90 },
+        {
+          name: 'Level 3 Vest',
+          quality: 'legendary',
+          level: 85
+        },
+        { name: 'Holographic Sight', quality: 'epic', level: 82 },
+        {
+          name: 'Suppressor',
+          quality: 'legendary',
+          level: 88
+        },
+        { name: 'Level 3 Backpack', quality: 'epic', level: 80 }
+      ]
+    ]);
   });
 });

test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -32,14 +32,14 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should deleteAt', () => {
-    expect(list.deleteAt(1)).toBe(true);
-    expect(list.deleteAt(-1)).toBe(false);
-    expect(list.deleteAt(list.size)).toBe(false);
-    expect(list.size).toBe(4);
-    expect(list.deleteAt(4)).toBe(false);
+    expect(list.deleteAt(1)).toBe(2);
+    expect(list.deleteAt(-1)).toBe(undefined);
+    expect(list.deleteAt(list.length)).toBe(undefined);
+    expect(list.length).toBe(4);
+    expect(list.deleteAt(4)).toBe(undefined);
     expect([...list]).toEqual([1, 3, 4, 5]);
     expect(list.isEmpty()).toBe(false);
-    expect(list.deleteAt(3)).toBe(true);
+    expect(list.deleteAt(3)).toBe(5);
     expect([...list]).toEqual([1, 3, 4]);
   });
 
@@ -103,7 +103,7 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should initialize an empty list', () => {
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -119,17 +119,36 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(1);
     list.push(2);
     list.push(3);
-    expect(list.size).toBe(3);
+    expect(list.length).toBe(3);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
   });
 
+  it('push with maxLen', () => {
+    const list = new DoublyLinkedList<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      list.push(i);
+    }
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.first).toBe(990);
+
+    list.clear();
+    for (let i = 0; i < 1000; i++) {
+      list.unshift(i);
+    }
+
+    expect(list.maxLen).toBe(10);
+    expect(list.length).toBe(10);
+    expect(list.last).toBe(990);
+  });
+
   it('should pop elements from the end of the list', () => {
     list.push(1);
     list.push(2);
     const poppedValue = list.pop();
     expect(poppedValue).toBe(2);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
     list.pop();
@@ -145,19 +164,19 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Inserting at the beginning
     list.addAt(0, 0);
-    expect(list.size).toBe(4);
+    expect(list.length).toBe(4);
     expect(list.at(0)).toBe(0);
     expect(list.at(1)).toBe(1);
 
     // Inserting in the middle
     list.addAt(2, 1.5);
-    expect(list.size).toBe(5);
+    expect(list.length).toBe(5);
     expect(list.at(2)).toBe(1.5);
     expect(list.at(3)).toBe(2);
 
     // Inserting at the end
     list.addAt(5, 4);
-    expect(list.size).toBe(6);
+    expect(list.length).toBe(6);
     expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
     expect(list.at(-1)).toBe(undefined);
@@ -171,18 +190,18 @@ describe('DoublyLinkedList Operation Test', () => {
 
     // Deleting from the beginning
     const deletedValue = list.deleteAt(0);
-    expect(deletedValue).toBe(true);
-    expect(list.size).toBe(2);
+    expect(deletedValue).toBe(1);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(2);
 
     // Deleting from the middle
     list.deleteAt(0); // Deleting the second element
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     // Deleting from the end
     list.deleteAt(0);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -193,16 +212,16 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(3);
 
     list.delete(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(3);
 
     list.delete(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
     expect(list.head!.value).toBe(3);
 
     list.delete(3);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -307,7 +326,7 @@ describe('DoublyLinkedList Operation Test', () => {
 
     list.clear();
 
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
   });
@@ -447,6 +466,95 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 });
 
+describe('DoublyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new DoublyLinkedList([1, 2]);
+    const list2 = new DoublyLinkedList([3, 4]);
+    const list3 = new DoublyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new DoublyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new DoublyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new DoublyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('iterable methods', () => {
   it('should forEach, some, every, filter, map, reduce of the deque', () => {
     const dl = new DoublyLinkedList<number>();
@@ -578,7 +686,7 @@ describe('classic use', () => {
         const initialNode = this.currentSong;
 
         // Loop through the playlist twice
-        for (let i = 0; i < this.playlist.size * 2; i++) {
+        for (let i = 0; i < this.playlist.length * 2; i++) {
           playedSongs.push(this.currentSong!.value);
           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
         }
@@ -700,7 +808,7 @@ describe('classic use', () => {
         }
 
         // Check capacity
-        if (this.list.size >= this.capacity) {
+        if (this.list.length >= this.capacity) {
           // Delete the least recently used element (the tail of the linked list)
           const removedNode = this.list.tail;
           if (removedNode) {
@@ -745,9 +853,9 @@ describe('classic use', () => {
         this.map.clear();
       }
 
-      // Get the current cache size
-      get size(): number {
-        return this.list.size;
+      // Get the current cache length
+      get length(): number {
+        return this.list.length;
       }
 
       // Check if it is empty
@@ -806,7 +914,7 @@ describe('classic use', () => {
 
     expect(cache.delete('a')).toBe(true);
     expect(cache.get('a')).toBeUndefined();
-    expect(cache.size).toBe(1);
+    expect(cache.length).toBe(1);
 
     // Should support clearing cache
     cache.clear();
@@ -814,7 +922,7 @@ describe('classic use', () => {
     cache.set('b', 2);
     cache.clear();
 
-    expect(cache.size).toBe(0);
+    expect(cache.length).toBe(0);
     expect(cache.isEmpty).toBe(true);
   });
 

test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -37,6 +37,16 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       expect(list.toArray()).toEqual([1, 2]);
     });
+
+    it('push with maxLen', () => {
+      const list = new SinglyLinkedList<number>([], { maxLen: 10 });
+      for (let i = 0; i < 1000; i++) {
+        list.push(i);
+      }
+      expect(list.maxLen).toBe(10);
+      expect(list.length).toBe(10);
+      expect(list.first).toBe(990);
+    });
   });
 
   describe('pop', () => {
@@ -187,7 +197,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       list.clear();
       expect(list.toArray()).toEqual([]);
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       expect(list.isEmpty()).toBe(true);
     });
   });
@@ -277,10 +287,10 @@ describe('SinglyLinkedList Operation Test', () => {
 
   describe('getLength', () => {
     it('should return the correct length of the list', () => {
-      expect(list.size).toBe(0);
+      expect(list.length).toBe(0);
       list.push(1);
       list.push(2);
-      expect(list.size).toBe(2);
+      expect(list.length).toBe(2);
     });
   });
 
@@ -290,14 +300,14 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(2);
       list.push(3);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1, 3]);
     });
 
     it('should return undefined for an out-of-bounds index', () => {
       list.push(1);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(false);
+      expect(removed).toBe(undefined);
     });
 
     it('should delete and return the first element', () => {
@@ -308,7 +318,7 @@ describe('SinglyLinkedList Operation Test', () => {
       const removed = list.deleteAt(0);
       expect(list.first).toBe(2);
       expect(list.last).toBe(2);
-      expect(removed).toBe(true);
+      expect(removed).toBe(1);
       expect(list.toArray()).toEqual([2]);
     });
 
@@ -316,7 +326,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);
-      expect(removed).toBe(true);
+      expect(removed).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
   });
@@ -448,6 +458,95 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 });
 
+describe('SinglyLinkedList Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new SinglyLinkedList([1, 2]);
+    const list2 = new SinglyLinkedList([3, 4]);
+    const list3 = new SinglyLinkedList([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new SinglyLinkedList([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new SinglyLinkedList(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new SinglyLinkedList([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('SinglyLinkedList', () => {
   let list: SinglyLinkedList<number>;
 
@@ -458,7 +557,7 @@ describe('SinglyLinkedList', () => {
   it('should initialize an empty list', () => {
     expect(list.head).toBe(undefined);
     expect(list.tail).toBe(undefined);
-    expect(list.size).toBe(0);
+    expect(list.length).toBe(0);
   });
 
   it('should push elements to the end of the list', () => {
@@ -466,7 +565,7 @@ describe('SinglyLinkedList', () => {
     list.push(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(2);
-    expect(list.size).toBe(2);
+    expect(list.length).toBe(2);
   });
 
   it('should pop elements from the end of the list', () => {
@@ -476,7 +575,7 @@ describe('SinglyLinkedList', () => {
     expect(popped).toBe(2);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
-    expect(list.size).toBe(1);
+    expect(list.length).toBe(1);
   });
 
   it('should reverse the list', () => {
@@ -545,7 +644,8 @@ describe('iterable methods', () => {
     expect(sl.some(element => element > 2)).toBe(true);
 
     expect([...sl.filter(element => element > 2)]).toEqual([3]);
-    expect([...sl.map(element => element * 2)]).toEqual([2, 4, 6]);
+    const mappedSl = sl.map(element => element * 2);
+    expect([...mappedSl]).toEqual([2, 4, 6]);
     expect(sl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
 });

test/unit/data-structures/queue/deque.test.ts

@@ -11,13 +11,13 @@ describe('Deque - Basic Operations', () => {
   });
 
   it('push should add elements to the end', () => {
-    expect(deque.size).toBe(2);
+    expect(deque.length).toBe(2);
     expect(deque.last).toBe(2);
   });
 
   it('pop should remove elements from the end', () => {
     expect(deque.pop()).toBe(2);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
     expect(deque.pop()).toBe(1);
     expect(deque.isEmpty()).toBeTruthy();
   });
@@ -26,7 +26,7 @@ describe('Deque - Basic Operations', () => {
     deque.clear();
     deque.unshift(1);
     deque.unshift(2);
-    expect(deque.size).toBe(2);
+    expect(deque.length).toBe(2);
     expect(deque.first).toBe(2);
   });
 
@@ -35,7 +35,7 @@ describe('Deque - Basic Operations', () => {
     deque.unshift(1);
     deque.unshift(2);
     expect(deque.shift()).toBe(2);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
     expect(deque.shift()).toBe(1);
     expect(deque.isEmpty()).toBeTruthy();
   });
@@ -88,24 +88,24 @@ describe('Deque - Basic Operations', () => {
     deque.push('0');
     deque.push('5');
     deque.push('9');
-    expect(deque.size).toBe(6);
+    expect(deque.length).toBe(6);
     deque.delete('2');
-    expect(deque.size).toBe(5);
+    expect(deque.length).toBe(5);
     expect([...deque]).toEqual(['1', '6', '0', '5', '9']);
     const cloned = deque.clone();
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-    expect(deque.size).toBe(5);
+    expect(deque.length).toBe(5);
     deque.delete('5');
-    expect(deque.size).toBe(4);
+    expect(deque.length).toBe(4);
     expect([...deque]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
-    expect(cloned.size).toBe(5);
+    expect(cloned.length).toBe(5);
     cloned.push('8');
-    expect(cloned.size).toBe(6);
+    expect(cloned.length).toBe(6);
     cloned.delete('6');
-    expect(cloned.size).toBe(5);
+    expect(cloned.length).toBe(5);
     cloned.delete('6');
-    expect(cloned.size).toBe(5);
+    expect(cloned.length).toBe(5);
   });
 });
 describe('Deque - Complex Operations', () => {
@@ -126,15 +126,15 @@ describe('Deque - Complex Operations', () => {
     deque.push(1);
     deque.push(2);
     deque.push(3);
-    expect(deque.size).toBe(3);
+    expect(deque.length).toBe(3);
     deque.cut(1, true);
-    expect(deque.size).toBe(2);
+    expect(deque.length).toBe(2);
     expect(deque.toArray()).toEqual([1, 2]);
 
     const dq1 = new Deque([1, 2, 3, 4, 5, 6, 7]);
-    expect(dq1.size).toBe(7);
+    expect(dq1.length).toBe(7);
     expect([...dq1.cut(3, true)]).toEqual([1, 2, 3, 4]);
-    expect(dq1.size).toBe(4);
+    expect(dq1.length).toBe(4);
     expect([...dq1]).toEqual([1, 2, 3, 4]);
     const dqCut = dq1.cut(2);
     expect(dqCut.toArray()).toEqual([1, 2, 3]);
@@ -228,7 +228,7 @@ describe('Deque - Complex Operations', () => {
 
   it('shrinkToFit should reduce the memory footprint', () => {
     deque.shrinkToFit();
-    expect(deque.size).toBe(0);
+    expect(deque.length).toBe(0);
     expect(deque.has(1)).toBe(false);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(0);
@@ -241,7 +241,7 @@ describe('Deque - Complex Operations', () => {
     deque.shrinkToFit();
 
     deque = new Deque([1, 2, 3, 4, 5], { bucketSize: 2 });
-    expect(deque.size).toBe(5);
+    expect(deque.length).toBe(5);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(2);
@@ -322,19 +322,19 @@ describe('Deque - Utility Operations', () => {
 
   it('should maxLen work well', () => {
     const dequeMaxLen = new Deque([3, 4, 5, 6, 7], { maxLen: 3 });
-    expect(dequeMaxLen.size).toBe(3);
+    expect(dequeMaxLen.length).toBe(3);
     expect(dequeMaxLen.toArray()).toEqual([5, 6, 7]);
     dequeMaxLen.unshift(4);
     dequeMaxLen.unshift(3);
-    expect(dequeMaxLen.size).toBe(3);
+    expect(dequeMaxLen.length).toBe(3);
     expect(dequeMaxLen.toArray()).toEqual([3, 4, 5]);
 
     const dequeNoMaxLen = new Deque([3, 4, 5, 6, 7]);
-    expect(dequeNoMaxLen.size).toBe(5);
+    expect(dequeNoMaxLen.length).toBe(5);
     expect(dequeNoMaxLen.toArray()).toEqual([3, 4, 5, 6, 7]);
     dequeNoMaxLen.unshift(4);
     dequeNoMaxLen.unshift(3);
-    expect(dequeNoMaxLen.size).toBe(7);
+    expect(dequeNoMaxLen.length).toBe(7);
     expect(dequeNoMaxLen.toArray()).toEqual([3, 4, 3, 4, 5, 6, 7]);
   });
 });
@@ -350,21 +350,21 @@ describe('Deque - Additional Operations', () => {
     deque.push(1);
     deque.push(2);
     expect(deque.last).toBe(2);
-    expect(deque.size).toBe(2);
+    expect(deque.length).toBe(2);
   });
 
   it('pop should remove and return the last element', () => {
     deque.push(1);
     deque.push(2);
     expect(deque.pop()).toBe(2);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('unshift should add an element to the beginning', () => {
     deque.unshift(1);
     deque.unshift(2);
     expect(deque.first).toBe(2);
-    expect(deque.size).toBe(2);
+    expect(deque.length).toBe(2);
   });
 
   it('shift should remove and return the first element', () => {
@@ -372,31 +372,31 @@ describe('Deque - Additional Operations', () => {
     deque.unshift(1);
     deque.unshift(2);
     expect(deque.shift()).toBe(2);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('clear should reset the deque', () => {
     deque.unshift(1);
     deque.clear();
-    expect(deque.size).toBe(0);
+    expect(deque.length).toBe(0);
     expect(deque.isEmpty()).toBeTruthy();
   });
 
-  it('begin should yield elements from the beginning', () => {
-    deque.push(1);
-    deque.push(2);
-    const iterator = deque.begin();
-    expect(iterator.next().value).toBe(1);
-    expect(iterator.next().value).toBe(2);
-  });
+  // it('begin should yield elements from the beginning', () => {
+  //   deque.push(1);
+  //   deque.push(2);
+  //   const iterator = deque.begin();
+  //   expect(iterator.next().value).toBe(1);
+  //   expect(iterator.next().value).toBe(2);
+  // });
 
-  it('reverseBegin should yield elements in reverse order', () => {
-    deque.push(1);
-    deque.push(2);
-    const iterator = deque.reverseBegin();
-    expect(iterator.next().value).toBe(2);
-    expect(iterator.next().value).toBe(1);
-  });
+  // it('reverseBegin should yield elements in reverse order', () => {
+  //   deque.push(1);
+  //   deque.push(2);
+  //   const iterator = deque.reverseBegin();
+  //   expect(iterator.next().value).toBe(2);
+  //   expect(iterator.next().value).toBe(1);
+  // });
 });
 describe('Deque - push Method', () => {
   let deque: Deque<number>;
@@ -411,7 +411,7 @@ describe('Deque - push Method', () => {
   it('push should add an element when deque is empty', () => {
     deque.push(1);
     expect(deque.last).toBe(1);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('push should add an element when lastInBucket is not at max', () => {
@@ -420,7 +420,7 @@ describe('Deque - push Method', () => {
     }
     deque.push(bucketSize);
     expect(deque.last).toBe(bucketSize);
-    expect(deque.size).toBe(bucketSize);
+    expect(deque.length).toBe(bucketSize);
   });
 
   it('push should add an element and move to next bucket when last bucket is full', () => {
@@ -429,7 +429,7 @@ describe('Deque - push Method', () => {
     }
     deque.push(bucketSize + 1);
     expect(deque.last).toBe(bucketSize + 1);
-    expect(deque.size).toBe(bucketSize + 1);
+    expect(deque.length).toBe(bucketSize + 1);
   });
 
   it('push should add an element and reallocate when last bucket and lastInBucket are at max', () => {
@@ -439,7 +439,7 @@ describe('Deque - push Method', () => {
 
     deque.push(100);
     expect(deque.last).toBe(100);
-    expect(deque.size).toBeGreaterThan(bucketSize);
+    expect(deque.length).toBeGreaterThan(bucketSize);
   });
 });
 describe('Deque - pop Method', () => {
@@ -456,7 +456,7 @@ describe('Deque - pop Method', () => {
     deque.push(1);
     deque.push(2);
     expect(deque.pop()).toBe(2);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('pop should handle popping the only element', () => {
@@ -488,7 +488,7 @@ describe('Deque - unshift Method', () => {
   it('unshift should add an element to the beginning when deque is empty', () => {
     deque.unshift(1);
     expect(deque.first).toBe(1);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('unshift should add an element to the beginning and adjust firstInBucket', () => {
@@ -523,7 +523,7 @@ describe('Deque - shift Method', () => {
     deque.push(1);
     deque.push(2);
     expect(deque.shift()).toBe(1);
-    expect(deque.size).toBe(1);
+    expect(deque.length).toBe(1);
   });
 
   it('shift should handle shifting the only element', () => {
@@ -543,6 +543,95 @@ describe('Deque - shift Method', () => {
   });
 });
 
+describe('Deque Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new Deque([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new Deque([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new Deque([1, 2]);
+    const list2 = new Deque([3, 4]);
+    const list3 = new Deque([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new Deque([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new Deque([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new Deque(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new Deque([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new Deque([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new Deque([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new Deque([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new Deque([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Deque([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Deque([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('Deque', () => {
   it('should initialize with default iterable with length function', () => {
     class IterableNumbers {
@@ -565,7 +654,7 @@ describe('Deque', () => {
 
     const numbers = new IterableNumbers([1, 6, 7, 3, 2, 4, 5]);
     const deque = new Deque(numbers, { bucketSize: 3 });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.bucketSize).toBe(3);
     expect(deque.maxLen).toBe(-1);
   });
@@ -591,7 +680,7 @@ describe('Deque', () => {
 
     const numbers = new IterableNumbersWithSize([1, 6, 7, 3, 2, 4, 5]);
     const deque = new Deque(numbers, { bucketSize: 3 });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.bucketSize).toBe(3);
     expect(deque.maxLen).toBe(-1);
   });
@@ -601,7 +690,7 @@ describe('Deque', () => {
       key: number;
     }> = [{ key: 1 }, { key: 6 }, { key: 7 }, { key: 3 }, { key: 2 }, { key: 4 }, { key: 5 }];
     const deque = new Deque<number>(objArr, { toElementFn: item => item.key });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.has(1)).toBe(true);
     expect(deque.has(7)).toBe(true);
     expect(deque.has(8)).toBe(false);
@@ -612,7 +701,7 @@ describe('Deque', () => {
       key: number;
     }> = [{ key: 1 }, { key: 6 }, { key: 7 }, { key: 3 }, { key: 2 }, { key: 4 }, { key: 5 }];
     const deque = new Deque<number>(objArr, { toElementFn: item => item.key, bucketSize: 3 });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(2);
@@ -628,7 +717,7 @@ describe('Deque', () => {
 
   it('should pop work well when bucket boundary is reached', () => {
     const deque = new Deque<number>([1, 6, 7, 3, 2, 4, 5], { bucketSize: 3 });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(2);
@@ -641,7 +730,7 @@ describe('Deque', () => {
       [4, 5]
     ]);
     for (let i = 0; i < 3; ++i) deque.pop();
-    expect(deque.size).toBe(4);
+    expect(deque.length).toBe(4);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(1);
@@ -654,7 +743,7 @@ describe('Deque', () => {
       [4, 5]
     ]); // TODO may be a problem
     deque.pop();
-    expect(deque.size).toBe(3);
+    expect(deque.length).toBe(3);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(1);
@@ -670,7 +759,7 @@ describe('Deque', () => {
 
   it('should shift work well when bucket boundary is reached and should shrinkToFit', () => {
     const deque = new Deque<number>([1, 6, 7, 3, 2, 4, 5], { bucketSize: 3 });
-    expect(deque.size).toBe(7);
+    expect(deque.length).toBe(7);
     expect(deque.has(1)).toBe(true);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(2);
@@ -683,7 +772,7 @@ describe('Deque', () => {
       [4, 5]
     ]);
     for (let i = 0; i < 3; ++i) deque.shift();
-    expect(deque.size).toBe(4);
+    expect(deque.length).toBe(4);
     expect(deque.has(1)).toBe(false);
     expect(deque.bucketFirst).toBe(1);
     expect(deque.bucketLast).toBe(2);
@@ -696,7 +785,7 @@ describe('Deque', () => {
       [4, 5]
     ]); // TODO may be a problem
     deque.shift();
-    expect(deque.size).toBe(3);
+    expect(deque.length).toBe(3);
     expect(deque.has(1)).toBe(false);
     expect(deque.bucketFirst).toBe(1);
     expect(deque.bucketLast).toBe(2);
@@ -709,7 +798,7 @@ describe('Deque', () => {
       [4, 5]
     ]); // TODO may be a problem
     deque.shrinkToFit();
-    expect(deque.size).toBe(3);
+    expect(deque.length).toBe(3);
     expect(deque.has(1)).toBe(false);
     expect(deque.bucketFirst).toBe(0);
     expect(deque.bucketLast).toBe(1);
@@ -722,3 +811,95 @@ describe('Deque', () => {
     ]); // TODO may be a problem
   });
 });
+
+describe('classic uses', () => {
+  it('@example prize roulette', () => {
+    class PrizeRoulette {
+      private deque: Deque<string>;
+
+      constructor(prizes: string[]) {
+        // Initialize the deque with prizes
+        this.deque = new Deque<string>(prizes);
+      }
+
+      // Rotate clockwise to the right (forward)
+      rotateClockwise(steps: number): void {
+        const n = this.deque.length;
+        if (n === 0) return;
+
+        for (let i = 0; i < steps; i++) {
+          const last = this.deque.pop(); // Remove the last element
+          this.deque.unshift(last!); // Add it to the front
+        }
+      }
+
+      // Rotate counterclockwise to the left (backward)
+      rotateCounterClockwise(steps: number): void {
+        const n = this.deque.length;
+        if (n === 0) return;
+
+        for (let i = 0; i < steps; i++) {
+          const first = this.deque.shift(); // Remove the first element
+          this.deque.push(first!); // Add it to the back
+        }
+      }
+
+      // Display the current prize at the head
+      display() {
+        return this.deque.first;
+      }
+    }
+
+    // Example usage
+    const prizes = ['Car', 'Bike', 'Laptop', 'Phone', 'Watch', 'Headphones']; // Initialize the prize list
+    const roulette = new PrizeRoulette(prizes);
+
+    // Display the initial state
+    expect(roulette.display()).toBe('Car'); // Car
+
+    // Rotate clockwise by 3 steps
+    roulette.rotateClockwise(3);
+    expect(roulette.display()).toBe('Phone'); // Phone
+
+    // Rotate counterclockwise by 2 steps
+    roulette.rotateCounterClockwise(2);
+    expect(roulette.display()).toBe('Headphones'); // Headphones
+  });
+
+  it('@example sliding window', () => {
+    // Maximum function of sliding window
+    function maxSlidingWindow(nums: number[], k: number): number[] {
+      const n = nums.length;
+      if (n * k === 0) return [];
+
+      const deq = new Deque<number>();
+      const result: number[] = [];
+
+      for (let i = 0; i < n; i++) {
+        // Delete indexes in the queue that are not within the window range
+        if (deq.length > 0 && deq.first! === i - k) {
+          deq.shift();
+        }
+
+        // Remove all indices less than the current value from the tail of the queue
+        while (deq.length > 0 && nums[deq.last!] < nums[i]) {
+          deq.pop();
+        }
+
+        // Add the current index to the end of the queue
+        deq.push(i);
+
+        // Add the maximum value of the window to the results
+        if (i >= k - 1) {
+          result.push(nums[deq.first!]);
+        }
+      }
+
+      return result;
+    }
+
+    const nums = [1, 3, -1, -3, 5, 3, 6, 7];
+    const k = 3;
+    expect(maxSlidingWindow(nums, k)).toEqual([3, 3, 5, 5, 6, 7]); // Output: [3, 3, 5, 5, 6, 7]
+  });
+});

test/unit/data-structures/queue/queue.test.ts

@@ -11,21 +11,21 @@ describe('Queue', () => {
   });
 
   it('new Queue() should create an empty queue', () => {
-    expect(queue.size).toBe(0);
+    expect(queue.length).toBe(0);
     expect(queue.isEmpty()).toBeTruthy();
   });
 
   it('push should add elements to the queue', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('shift should remove the first element', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.shift()).toBe(1);
-    expect(queue.size).toBe(1);
+    expect(queue.length).toBe(1);
   });
 
   it('shift should return undefined if queue is empty', () => {
@@ -36,17 +36,17 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.first).toBe(1);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('first should return undefined if queue is empty', () => {
     expect(queue.first).toBeUndefined();
   });
 
-  it('size should return the number of elements', () => {
+  it('length should return the number of elements', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('isEmpty should return true if the queue is empty', () => {
@@ -68,7 +68,7 @@ describe('Queue', () => {
     queue.push(1);
     queue.push(2);
     queue.clear();
-    expect(queue.size).toBe(0);
+    expect(queue.length).toBe(0);
   });
 
   it('forEach should iterate over all elements', () => {
@@ -90,6 +90,16 @@ describe('Queue', () => {
     expect(queue.isEmpty()).toBeTruthy();
   });
 
+  it('push with maxLen', () => {
+    const queue = new Queue<number>([], { maxLen: 10 });
+    for (let i = 0; i < 1000; i++) {
+      queue.push(i);
+    }
+    expect(queue.maxLen).toBe(10);
+    expect(queue.length).toBe(10);
+    expect(queue.first).toBe(990);
+  });
+
   it('compact method should work well', () => {
     for (let i = 0; i < 1000; i++) queue.push(i);
 
@@ -119,9 +129,9 @@ describe('Queue', () => {
       toElementFn: rawElement => rawElement.id
     });
 
-    expect(queue.size).toBe(5);
+    expect(queue.length).toBe(5);
     queue.shift();
-    expect(queue.size).toBe(4);
+    expect(queue.length).toBe(4);
     expect(queue.at(1)).toBe('3');
   });
 
@@ -193,11 +203,11 @@ describe('Queue', () => {
     queue.push(9);
     queue.push(10);
     expect(queue.elements.length).toBe(10);
-    while (queue.size > 7) queue.shift();
-    expect(queue.size).toBe(7);
+    while (queue.length > 7) queue.shift();
+    expect(queue.length).toBe(7);
     expect(queue.elements.length).toBe(10);
     queue.shift();
-    expect(queue.size).toBe(6);
+    expect(queue.length).toBe(6);
     expect(queue.elements.length).toBe(6);
   });
 });
@@ -260,7 +270,7 @@ describe('Queue - Additional Methods', () => {
     queue.push(1);
     queue.push(2);
     expect(queue.last).toBe(2);
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('peekLast should return undefined if queue is empty', () => {
@@ -288,12 +298,101 @@ describe('Queue - Additional Methods', () => {
   });
 });
 
+describe('Queue Additional Methods', () => {
+  // Slice method implementation and test
+  test('slice should return a new list with specified range', () => {
+    const list = new Queue([1, 2, 3, 4, 5]);
+    const slicedList = list.slice(1, 4);
+
+    expect(slicedList.toArray()).toEqual([2, 3, 4]);
+    expect(list.length).toBe(5); // Original list unchanged
+  });
+
+  // Splice method implementation
+  test('splice should modify list and return removed elements', () => {
+    const list = new Queue([1, 2, 3, 4, 5]);
+    const removedList = list.splice(2, 2, 6, 7);
+
+    expect(list.toArray()).toEqual([1, 2, 6, 7, 5]);
+    expect(removedList.toArray()).toEqual([3, 4]);
+  });
+
+  // Concat method test
+  test('concat should combine multiple lists', () => {
+    const list1 = new Queue([1, 2]);
+    const list2 = new Queue([3, 4]);
+    const list3 = new Queue([5, 6]);
+
+    const concatenatedList = list1.concat(list2, list3);
+    expect(concatenatedList.toArray()).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  // Sort method test
+  test('sort should order elements in ascending order', () => {
+    const list = new Queue([5, 2, 8, 1, 9]);
+    list.sort((a, b) => a - b);
+
+    expect(list.toArray()).toEqual([1, 2, 5, 8, 9]);
+  });
+
+  // Reverse method test
+  test('reverse should invert the list order', () => {
+    const list = new Queue([1, 2, 3, 4, 5]);
+    list.reverse();
+
+    expect(list.toArray()).toEqual([5, 4, 3, 2, 1]);
+  });
+
+  // Join method test
+  test('join should convert list to string with separator', () => {
+    const list = new Queue(['a', 'b', 'c']);
+
+    expect(list.join('-')).toBe('a-b-c');
+    expect(list.join()).toBe('a,b,c');
+  });
+
+  // IndexOf method test
+  test('indexOf should return first occurrence index', () => {
+    const list = new Queue([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2)).toBe(1);
+    expect(list.indexOf(4)).toBe(-1);
+  });
+
+  // LastIndexOf method test
+  test('lastIndexOf should return last occurrence index', () => {
+    const list = new Queue([1, 2, 3, 2, 1]);
+
+    expect(list.lastIndexOf(2)).toBe(3);
+    expect(list.lastIndexOf(4)).toBe(-1);
+  });
+
+  // findIndex method test
+  test('findIndex should return first occurrence index', () => {
+    const list = new Queue([1, 2, 3, 2, 1]);
+    expect(list.findIndex(item => item === 2)).toBe(1);
+    expect(list.findIndex(item => item === 4)).toBe(-1);
+  });
+
+  // fill method test
+  test('fill should return fill all the list', () => {
+    let list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9)]).toEqual([9, 9, 9, 9, 9]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, 2, 3)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -3, -2)]).toEqual([1, 2, 9, 2, 1]);
+    list = new Queue([1, 2, 3, 2, 1]);
+    expect([...list.fill(9, -2, -3)]).toEqual([1, 2, 3, 2, 1]);
+  });
+});
+
 describe('Queue - Static and Clone Methods', () => {
   it('fromArray should create a new queue from an array', () => {
     const array = [1, 2, 3];
     const queue = Queue.fromArray(array);
     expect(queue.toArray()).toEqual(array);
-    expect(queue.size).toBe(array.length);
+    expect(queue.length).toBe(array.length);
   });
 
   it('fromArray should create an empty queue from an empty array', () => {
@@ -308,7 +407,7 @@ describe('Queue - Static and Clone Methods', () => {
 
     const clonedQueue = originalQueue.clone();
     expect(clonedQueue.toArray()).toEqual(originalQueue.toArray());
-    expect(clonedQueue.size).toBe(originalQueue.size);
+    expect(clonedQueue.length).toBe(originalQueue.length);
   });
 
   it('clone should not affect the original queue when mutated', () => {
@@ -319,7 +418,7 @@ describe('Queue - Static and Clone Methods', () => {
     const clonedQueue = originalQueue.clone();
     clonedQueue.push(3);
 
-    expect(clonedQueue.size).not.toBe(originalQueue.size);
+    expect(clonedQueue.length).not.toBe(originalQueue.length);
     expect(originalQueue.toArray()).not.toContain(3);
   });
 });
@@ -335,14 +434,14 @@ describe('LinkedListQueue', () => {
 
   it('should push elements to the end of the queue', () => {
     expect(queue.first).toBe('A');
-    expect(queue.size).toBe(2);
+    expect(queue.length).toBe(2);
   });
 
   it('should shift elements from the front of the queue', () => {
     const dequeued = queue.shift();
     expect(dequeued).toBe('A');
     expect(queue.first).toBe('B');
-    expect(queue.size).toBe(1);
+    expect(queue.length).toBe(1);
   });
 
   it('should peek at the front of the queue', () => {
@@ -352,6 +451,6 @@ describe('LinkedListQueue', () => {
   it('should clone method work correctly', () => {
     const cloned = queue.clone();
     expect(cloned instanceof LinkedListQueue).toBe(true);
-    expect(cloned.size).toBe(2);
+    expect(cloned.length).toBe(2);
   });
 });

test/unit/unrestricted-interconversion.test.ts

@@ -263,7 +263,7 @@ describe('conversions', () => {
       'triangle'
     ]);
     const dq = new Deque<string>(heap);
-    expect(dq.size).toBe(10);
+    expect(dq.length).toBe(10);
     if (isDebug) dq.print();
     expect([...dq]).toEqual([
       'transmit',