min-heap-typed 1.39.1 → 1.39.3

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

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, OneParamCallback} from '../../types';
+import type {BTNKey, BSTComparator, BSTNodeNested, BSTOptions, BTNCallback} from '../../types';
 import {CP, IterationType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  constructor(key: BinaryTreeNodeKey, val?: V) {
+  constructor(key: BTNKey, val?: V) {
     super(key, val);
   }
 }
@@ -39,27 +39,27 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
   /**
    * The function creates a new binary search tree node with the given key and value.
-   * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
+   * @param {BTNKey} key - The key parameter is the key value that will be associated with
    * the new node. It is used to determine the position of the node in the binary search tree.
    * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
    * represents the value associated with the node in a binary search tree.
    * @returns a new instance of the BSTNode class with the specified key and value.
    */
-  override createNode(key: BinaryTreeNodeKey, val?: V): N {
+  override createNode(key: BTNKey, val?: V): N {
     return new BSTNode<V, N>(key, val) as N;
   }
 
   /**
    * The `add` function in a binary search tree class inserts a new node with a given key and value
    * into the tree.
-   * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-   * `BinaryTreeNodeKey` (which can be a number or a string), a `BSTNode` object, or `null`.
+   * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+   * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
    * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
    * binary search tree.
    * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
    * was not added or if the parameters were invalid, it returns null or undefined.
    */
-  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
     // TODO support node as a parameter
     let inserted: N | null = null;
     let newNode: N | null = null;
@@ -128,9 +128,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
    * maintaining balance.
-   * @param {[BinaryTreeNodeKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+   * @param {[BTNKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
    * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
-   * array of `BinaryTreeNodeKey` or `N` (which represents the node type in the binary search tree) or
+   * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
    * `null
    * @param {V[]} data - The values of tree nodes
    * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
@@ -140,13 +140,13 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
 
   override addMany(
-    keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
+    keysOrNodes: (BTNKey | null)[] | (N | null)[],
     data?: V[],
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | null | undefined)[] {
     // TODO this addMany function is inefficient, it should be optimized
-    function hasNoNull(arr: (BinaryTreeNodeKey | null)[] | (N | null)[]): arr is BinaryTreeNodeKey[] | N[] {
+    function hasNoNull(arr: (BTNKey | null)[] | (N | null)[]): arr is BTNKey[] | N[] {
       return arr.indexOf(null) === -1;
     }
 
@@ -154,17 +154,15 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BinaryTreeNodeKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BTNKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BinaryTreeNodeKey | N, N['val']][]): arr is [N, N['val']][] {
+    function isNodeOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [N, N['val']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(
-      arr: [BinaryTreeNodeKey | N, N['val']][]
-    ): arr is [BinaryTreeNodeKey, N['val']][] {
+    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [BTNKey, N['val']][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }
@@ -181,7 +179,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     }
     sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
     sortedData = sorted.map(([, val]) => val);
-    const recursive = (arr: (BinaryTreeNodeKey | null | N)[], data?: (V | undefined)[]) => {
+    const recursive = (arr: (BTNKey | null | N)[], data?: (V | undefined)[]) => {
       if (arr.length === 0) return;
 
       const mid = Math.floor((arr.length - 1) / 2);
@@ -221,7 +219,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * callback.
    * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter is used to specify the
    * property of the binary tree node that you want to search for. It can be either a specific key
-   * value (`BinaryTreeNodeKey`) or a custom callback function (`OneParamCallback<N>`) that determines
+   * value (`BTNKey`) or a custom callback function (`BTNCallback<N>`) that determines
    * whether a node matches the desired property.
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired property. It takes a node as input and returns a boolean value indicating
@@ -234,7 +232,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns either the first node that matches the given nodeProperty and callback, or null if no
    * matching node is found.
    */
-  override get<C extends OneParamCallback<N>>(
+  override get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
@@ -258,7 +256,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * the key of the leftmost node if the comparison result is greater than, and the key of the
    * rightmost node otherwise. If no node is found, it returns 0.
    */
-  lastKey(beginRoot: N | null = this.root, iterationType = this.iterationType): BinaryTreeNodeKey {
+  lastKey(beginRoot: N | null = this.root, iterationType = this.iterationType): BTNKey {
     if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
     else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -268,7 +266,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
    * using either recursive or iterative traversal.
    * @param {ReturnType<C> | N} identifier - The `nodeProperty` parameter represents the property
-   * of the binary tree node that you want to search for. It can be either a `BinaryTreeNodeKey` or a
+   * of the binary tree node that you want to search for. It can be either a `BTNKey` or a
    * generic type `N`.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `nodeProperty` parameter to determine if the node should be
@@ -285,7 +283,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * traverse the binary tree. It can have one of the following values:
    * @returns an array of nodes (N[]).
    */
-  override getNodes<C extends OneParamCallback<N>>(
+  override getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
@@ -351,22 +349,22 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @param {CP} lesserOrGreater - The `lesserOrGreater` parameter is used to determine whether to
    * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It can take one
    * of the following values:
-   * @param {BinaryTreeNodeKey | N | null} targetNode - The `targetNode` parameter in the
+   * @param {BTNKey | N | null} targetNode - The `targetNode` parameter in the
    * `lesserOrGreaterTraverse` function is used to specify the node from which the traversal should
    * start. It can be either a reference to a specific node (`N`), the key of a node
-   * (`BinaryTreeNodeKey`), or `null` to
+   * (`BTNKey`), or `null` to
    * @param iterationType - The `iterationType` parameter determines whether the traversal should be
    * done recursively or iteratively. It can have two possible values:
-   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
+   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
-  lesserOrGreaterTraverse<C extends OneParamCallback<N>>(
+  lesserOrGreaterTraverse<C extends BTNCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     lesserOrGreater: CP = CP.lt,
-    targetNode: BinaryTreeNodeKey | N | null = this.root,
+    targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof targetNode === 'number') targetNode = this.get(targetNode);
-    const ans: ReturnType<OneParamCallback<N>>[] = [];
+    const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;
     if (!this.root) return ans;
@@ -509,12 +507,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The function compares two values using a comparator function and returns whether the first value
    * is greater than, less than, or equal to the second value.
-   * @param {BinaryTreeNodeKey} a - The parameter "a" is of type BinaryTreeNodeKey.
-   * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code represents a BinaryTreeNodeKey.
+   * @param {BTNKey} a - The parameter "a" is of type BTNKey.
+   * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
    * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
    * than), CP.lt (less than), or CP.eq (equal).
    */
-  protected _compare(a: BinaryTreeNodeKey, b: BinaryTreeNodeKey): CP {
+  protected _compare(a: BTNKey, b: BTNKey): CP {
     const compared = this._comparator(a, b);
     if (compared > 0) return CP.gt;
     else if (compared < 0) return CP.lt;

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

@@ -1,9 +1,9 @@
-import {BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
+import {BTNKey, RBColor, RBTreeNodeNested, RBTreeOptions} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {BST, BSTNode} from './bst';
 
 export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-  constructor(key: BinaryTreeNodeKey, val?: V) {
+  constructor(key: BTNKey, val?: V) {
     super(key, val);
     this._color = RBColor.RED;
   }
@@ -27,11 +27,11 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
     super(options);
   }
 
-  override createNode(key: BinaryTreeNodeKey, val?: V): N {
+  override createNode(key: BTNKey, val?: V): N {
     return new RBTreeNode(key, val) as N;
   }
 
-  // override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V): N | null | undefined {
+  // override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
   //   const inserted = super.add(keyOrNode, val);
   //   if (inserted) this._fixInsertViolation(inserted);
   //   return inserted;
@@ -205,7 +205,7 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
   //   node.right = null;
   // }
   //
-  // override delete(keyOrNode: BinaryTreeNodeKey | N): BinaryTreeDeletedResult<N>[] {
+  // override delete(keyOrNode: BTNKey | N): BinaryTreeDeletedResult<N>[] {
   //   const node = this.get(keyOrNode);
   //   const result: BinaryTreeDeletedResult<N>[] = [{deleted: undefined, needBalanced: null}];
   //   if (!node) return result; // Node does not exist

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, OneParamCallback} from '../../types';
+import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, BTNCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -18,7 +18,7 @@ export class TreeMultisetNode<
 
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-   * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
+   * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
    * of the binary tree node.
    * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
    * tree node. If no value is provided, it will be `undefined`.
@@ -26,7 +26,7 @@ export class TreeMultisetNode<
    * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
    * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(key: BinaryTreeNodeKey, val?: V, count = 1) {
+  constructor(key: BTNKey, val?: V, count = 1) {
     super(key, val);
     this.count = count;
   }
@@ -57,22 +57,22 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
 
   /**
    * The function creates a new BSTNode with the given key, value, and count.
-   * @param {BinaryTreeNodeKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+   * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
    * distinguish one node from another in the tree.
    * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
    * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
    * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(key: BinaryTreeNodeKey, val?: V, count?: number): N {
+  override createNode(key: BTNKey, val?: V, count?: number): N {
     return new TreeMultisetNode(key, val, count) as N;
   }
 
   /**
    * The `add` function adds a new node to a binary search tree, updating the count if the key already
    * exists, and balancing the tree if necessary.
-   * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
-   * `BinaryTreeNodeKey` (which represents the key of the node to be added), a `N` (which represents a
+   * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
+   * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
    * node to be added), or `null` (which represents a null node).
    * @param [val] - The `val` parameter represents the value associated with the key that is being
    * added to the binary tree.
@@ -81,7 +81,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * count is specified, the default count will be 1.
    * @returns The function `add` returns a value of type `N | null | undefined`.
    */
-  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: V, count = 1): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, val?: V, count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
     if (keyOrNode instanceof TreeMultisetNode) {
@@ -185,14 +185,14 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
   /**
    * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the
    * inserted nodes.
-   * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
-   * added to the multiset. Each element can be either a BinaryTreeNodeKey or a TreeMultisetNode.
+   * @param {(BTNKey | null)[] | (N | null)[]} keysOrNodes - An array of keys or nodes to be
+   * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode.
    * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond
    * to the keys or nodes being added to the multiset. It is used to associate additional data with
    * each key or node.
    * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
    */
-  override addMany(keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[] {
+  override addMany(keysOrNodes: (BTNKey | null)[] | (N | null)[], data?: V[]): (N | null | undefined)[] {
     const inserted: (N | null | undefined)[] = [];
 
     for (let i = 0; i < keysOrNodes.length; i++) {
@@ -263,7 +263,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * The `delete` function in a binary search tree deletes a node from the tree and returns the deleted
    * node along with the parent node that needs to be balanced.
    * @param {ReturnType<C>} identifier - The `identifier` parameter is either a
-   * `BinaryTreeNodeKey` or a generic type `N`. It represents the property of the node that we are
+   * `BTNKey` or a generic type `N`. It represents the property of the node that we are
    * searching for. It can be a specific key value or any other property of the node.
    * @param callback - The `callback` parameter is a function that takes a node as input and returns a
    * value. This value is compared with the `identifier` parameter to determine if the node should be
@@ -275,7 +275,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * decremented by 1 and
    * @returns The method `delete` returns an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete<C extends OneParamCallback<N>>(
+  override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultCallbackByKey as C,
     ignoreCount = false

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

@@ -147,11 +147,11 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+   * The `popLast()` function removes and returns the value of the last node in a doubly linked list.
    * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
    * list is empty, it returns null.
    */
-  pollLast(): E | undefined {
+  popLast(): E | undefined {
     return this.pop();
   }
 
@@ -175,11 +175,11 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+   * The `popFirst()` function removes and returns the value of the first node in a doubly linked list.
    * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
    * list.
    */
-  pollFirst(): E | undefined {
+  popFirst(): E | undefined {
     return this.shift();
   }
 
@@ -211,18 +211,18 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `peekFirst` function returns the first node in a doubly linked list, or null if the list is empty.
-   * @returns The method `peekFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
+   * The `getFirst` function returns the first node in a doubly linked list, or null if the list is empty.
+   * @returns The method `getFirst()` returns the first node of the doubly linked list, or `null` if the list is empty.
    */
-  peekFirst(): E | undefined {
+  getFirst(): E | undefined {
     return this.head?.val;
   }
 
   /**
-   * The `peekLast` function returns the last node in a doubly linked list, or null if the list is empty.
-   * @returns The method `peekLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
+   * The `getLast` function returns the last node in a doubly linked list, or null if the list is empty.
+   * @returns The method `getLast()` returns the last node of the doubly linked list, or `null` if the list is empty.
    */
-  peekLast(): E | undefined {
+  getLast(): E | undefined {
     return this.tail?.val;
   }
 
@@ -266,7 +266,7 @@ export class DoublyLinkedList<E = any> {
    * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<E>` if a node with the specified value `val`
    * is found in the linked list. If no such node is found, it returns `null`.
    */
-  findNode(val: E | null): DoublyLinkedListNode<E> | null {
+  getNode(val: E | null): DoublyLinkedListNode<E> | null {
     let current = this.head;
 
     while (current) {
@@ -310,6 +310,43 @@ export class DoublyLinkedList<E = any> {
     return true;
   }
 
+  /**
+   * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
+   * before which the new value will be inserted. It can be either the value of the existing node or the existing node
+   * itself.
+   * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
+   * list.
+   * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
+   * insertion fails.
+   */
+  insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
+    let existingNode;
+
+    if (existingValueOrNode instanceof DoublyLinkedListNode) {
+      existingNode = existingValueOrNode;
+    } else {
+      existingNode = this.getNode(existingValueOrNode);
+    }
+
+    if (existingNode) {
+      const newNode = new DoublyLinkedListNode(newValue);
+      newNode.prev = existingNode.prev;
+      if (existingNode.prev) {
+        existingNode.prev.next = newNode;
+      }
+      newNode.next = existingNode;
+      existingNode.prev = newNode;
+      if (existingNode === this.head) {
+        this.head = newNode;
+      }
+      this._length++;
+      return true;
+    }
+
+    return false;
+  }
+
   /**
    * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
    * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
@@ -331,9 +368,6 @@ export class DoublyLinkedList<E = any> {
     return removedNode!.val;
   }
 
-  delete(valOrNode: E): boolean;
-  delete(valOrNode: DoublyLinkedListNode<E>): boolean;
-
   /**
    * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
    * @param {E | DoublyLinkedListNode<E>} valOrNode - The `valOrNode` parameter can accept either a value of type `E` or
@@ -347,7 +381,7 @@ export class DoublyLinkedList<E = any> {
     if (valOrNode instanceof DoublyLinkedListNode) {
       node = valOrNode;
     } else {
-      node = this.findNode(valOrNode);
+      node = this.getNode(valOrNode);
     }
 
     if (node) {
@@ -437,14 +471,14 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+   * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
    * value that satisfies the given callback function, or null if no value satisfies the callback.
    * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
    * function is used to determine whether a given value satisfies a certain condition.
-   * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+   * @returns The method `findBackward` returns the last value in the linked list that satisfies the condition specified by
    * the callback function. If no value satisfies the condition, it returns `null`.
    */
-  findLast(callback: (val: E) => boolean): E | null {
+  findBackward(callback: (val: E) => boolean): E | null {
     let current = this.tail;
     while (current) {
       if (callback(current.val)) {
@@ -456,10 +490,10 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
-   * @returns The `toArrayReverse()` function returns an array of type `E[]`.
+   * The `toArrayBackward` function converts a doubly linked list into an array in reverse order.
+   * @returns The `toArrayBackward()` function returns an array of type `E[]`.
    */
-  toArrayReverse(): E[] {
+  toArrayBackward(): E[] {
     const array: E[] = [];
     let current = this.tail;
     while (current) {
@@ -555,9 +589,6 @@ export class DoublyLinkedList<E = any> {
     return accumulator;
   }
 
-  insertAfter(existingValueOrNode: E, newValue: E): boolean;
-  insertAfter(existingValueOrNode: DoublyLinkedListNode<E>, newValue: E): boolean;
-
   /**
    * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
    * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
@@ -573,7 +604,7 @@ export class DoublyLinkedList<E = any> {
     if (existingValueOrNode instanceof DoublyLinkedListNode) {
       existingNode = existingValueOrNode;
     } else {
-      existingNode = this.findNode(existingValueOrNode);
+      existingNode = this.getNode(existingValueOrNode);
     }
 
     if (existingNode) {
@@ -595,39 +626,14 @@ export class DoublyLinkedList<E = any> {
   }
 
   /**
-   * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
-   * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
-   * before which the new value will be inserted. It can be either the value of the existing node or the existing node
-   * itself.
-   * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the doubly linked
-   * list.
-   * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
-   * insertion fails.
+   * The function returns an iterator that iterates over the values of a linked list.
    */
-  insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean {
-    let existingNode;
-
-    if (existingValueOrNode instanceof DoublyLinkedListNode) {
-      existingNode = existingValueOrNode;
-    } else {
-      existingNode = this.findNode(existingValueOrNode);
-    }
+  *[Symbol.iterator]() {
+    let current = this.head;
 
-    if (existingNode) {
-      const newNode = new DoublyLinkedListNode(newValue);
-      newNode.prev = existingNode.prev;
-      if (existingNode.prev) {
-        existingNode.prev.next = newNode;
-      }
-      newNode.next = existingNode;
-      existingNode.prev = newNode;
-      if (existingNode === this.head) {
-        this.head = newNode;
-      }
-      this._length++;
-      return true;
+    while (current) {
+      yield current.val;
+      current = current.next;
     }
-
-    return false;
   }
 }