linked-list-typed 1.39.0 → 1.39.2

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

@@ -85,44 +85,44 @@ class ObjectDeque {
         this._size++;
     }
     /**
-     * The function `pollFirst()` removes and returns the first element in a data structure.
+     * The function `popFirst()` removes and returns the first element in a data structure.
      * @returns The value of the first element in the data structure.
      */
-    pollFirst() {
+    popFirst() {
         if (!this._size)
             return;
-        const value = this.peekFirst();
+        const value = this.getFirst();
         delete this._nodes[this._first];
         this._first++;
         this._size--;
         return value;
     }
     /**
-     * The `peekFirst` function returns the first element in an array-like data structure if it exists.
+     * The `getFirst` function returns the first element in an array-like data structure if it exists.
      * @returns The element at the first position of the `_nodes` array.
      */
-    peekFirst() {
+    getFirst() {
         if (this._size)
             return this._nodes[this._first];
     }
     /**
-     * The `pollLast()` function removes and returns the last element in a data structure.
+     * The `popLast()` function removes and returns the last element in a data structure.
      * @returns The value that was removed from the data structure.
      */
-    pollLast() {
+    popLast() {
         if (!this._size)
             return;
-        const value = this.peekLast();
+        const value = this.getLast();
         delete this._nodes[this._last];
         this._last--;
         this._size--;
         return value;
     }
     /**
-     * The `peekLast()` function returns the last element in an array-like data structure.
+     * The `getLast()` function returns the last element in an array-like data structure.
      * @returns The last element in the array "_nodes" is being returned.
      */
-    peekLast() {
+    getLast() {
         if (this._size)
             return this._nodes[this._last];
     }
@@ -172,19 +172,19 @@ class ArrayDeque {
         return this._nodes.push(value);
     }
     /**
-     * The function "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    pollLast() {
+    popLast() {
         var _a;
         return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
      * empty.
      */
-    pollFirst() {
+    popFirst() {
         var _a;
         return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
     }
@@ -201,19 +201,19 @@ class ArrayDeque {
         return this._nodes.unshift(value);
     }
     /**
-     * The `peekFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
      * empty, it will return `null`.
      */
-    peekFirst() {
+    getFirst() {
         var _a;
         return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * The `peekLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
      */
-    peekLast() {
+    getLast() {
         var _a;
         return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
     }

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

@@ -68,11 +68,11 @@ export declare class Queue<E = any> {
      */
     peek(): E | undefined;
     /**
-     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    peekLast(): E | undefined;
+    getLast(): E | undefined;
     /**
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.

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

@@ -109,11 +109,11 @@ class Queue {
         return this.size > 0 ? this.nodes[this.offset] : undefined;
     }
     /**
-     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
      */
-    peekLast() {
+    getLast() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
     }
     /**

package/dist/interfaces/binary-tree.d.ts

@@ -1,7 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, MapCallback } from '../types';
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodeNested, OneParamCallback } from '../types';
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
     add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
-    delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
+    delete<C extends OneParamCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
 }

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

@@ -19,8 +19,6 @@ export declare enum FamilyPosition {
     MAL_NODE = "MAL_NODE"
 }
 export type BinaryTreeNodeKey = number;
-export type BFSCallback<N, D = any> = (node: N, level?: number) => D;
-export type BFSCallbackReturn<N> = ReturnType<BFSCallback<N>>;
 export type BinaryTreeDeletedResult<N> = {
     deleted: N | null | undefined;
     needBalanced: N | null;

package/dist/types/helpers.d.ts

@@ -1,9 +1,6 @@
-import { BinaryTreeNodeKey } from './data-structures';
 export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
-export type MapCallback<N, D = any> = (node: N) => D;
-export type DefaultMapCallback<N, D = BinaryTreeNodeKey> = (node: N) => D;
-export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export type OneParamCallback<N, D = any> = (node: N) => D;
 export declare enum CP {
     lt = "lt",
     eq = "eq",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.39.0",
+  "version": "1.39.2",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.39.0"
+    "data-structure-typed": "^1.39.2"
   }
 }

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

@@ -7,7 +7,7 @@
  */
 import {BST, BSTNode} from './bst';
 import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../../types';
-import {MapCallback} from '../../types';
+import {OneParamCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 
 export class AVLTreeNode<V = any, N extends AVLTreeNode<V, N> = AVLTreeNodeNested<V>> extends BSTNode<V, N> {
@@ -73,7 +73,7 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * `this._defaultCallbackByKey`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override delete<C extends MapCallback<N>>(
+  override delete<C extends OneParamCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultCallbackByKey as C
   ): BinaryTreeDeletedResult<N>[] {

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

@@ -6,16 +6,8 @@
  * @license MIT License
  */
 
-import type {
-  BFSCallback,
-  BFSCallbackReturn,
-  BinaryTreeNodeKey,
-  BinaryTreeNodeNested,
-  BinaryTreeOptions,
-  MapCallback,
-  MapCallbackReturn
-} from '../../types';
-import {BinaryTreeDeletedResult, DefaultMapCallback, DFSOrderPattern, FamilyPosition, IterationType} from '../../types';
+import type {BinaryTreeNodeKey, BinaryTreeNodeNested, BinaryTreeOptions, OneParamCallback} from '../../types';
+import {BinaryTreeDeletedResult, DFSOrderPattern, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {trampoline} from '../../utils';
 import {Queue} from '../queue';
@@ -285,10 +277,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return keysOrNodes.length === this.addMany(keysOrNodes, data).length;
   }
 
-  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N): BinaryTreeDeletedResult<N>[];
-
-  delete<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): BinaryTreeDeletedResult<N>[];
-
   /**
    * The `delete` function removes a node from a binary search tree and returns the deleted node along
    * with the parent node that needs to be balanced.
@@ -303,13 +291,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * included in the result. The `callback` parameter has a default value of
    * `this._defaultCallbackByKey`, which
    */
-  delete<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  delete<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
 
     const curr = this.get(identifier, callback);
     if (!curr) return bstDeletedResult;
@@ -320,7 +308,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
     if (!curr.left) {
       if (!parent) {
-        if (curr.right !== undefined) this._setRoot(curr.right);
+        // Handle the case when there's only one root node
+        this._setRoot(null);
       } else {
         const {familyPosition: fp} = curr;
         if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
@@ -489,29 +478,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return this.getMinHeight(beginRoot) + 1 >= this.getHeight(beginRoot);
   }
 
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, onlyOne: boolean): N[];
-
-  getNodes<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, onlyOne: boolean): N[];
-
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    onlyOne: boolean,
-    beginRoot: N | null
-  ): N[];
-
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    onlyOne: boolean,
-    beginRoot: N | null,
-    iterationType: IterationType
-  ): N[];
-
   /**
    * The function `getNodes` returns an array of nodes that match a given node property, using either
    * recursive or iterative traversal.
@@ -533,15 +499,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * traverse the binary tree. It can have two possible values:
    * @returns The function `getNodes` returns an array of nodes (`N[]`).
    */
-  getNodes<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  getNodes<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): N[] {
     if (!beginRoot) return [];
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     const ans: N[] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -574,14 +540,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, beginRoot: N | null): boolean;
-
-  has<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, beginRoot: N | null): boolean;
-
   /**
    * The function checks if a binary tree has a node with a given property or key.
    * @param {BinaryTreeNodeKey | N} identifier - The `identifier` parameter is the key or value of
@@ -599,32 +557,17 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for nodes in the binary tree. It can have one of the following values:
    * @returns a boolean value.
    */
-  has<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  has<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): boolean {
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     // TODO may support finding node by value equal
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, beginRoot: N | null): N | null;
-
-  get<C extends MapCallback<N>>(identifier: ReturnType<C> | N, callback: C, beginRoot: N | null): N | null;
-
-  get<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
-    callback: C,
-    beginRoot: N | null,
-    iterationType: IterationType
-  ): N | null;
-
   /**
    * The function `get` returns the first node in a binary tree that matches the given property or key.
    * @param {BinaryTreeNodeKey | N} identifier - The `identifier` parameter is the key or value of
@@ -640,13 +583,13 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * performed when searching for a node in the binary tree. It can have one of the following values:
    * @returns either the found node (of type N) or null if no node is found.
    */
-  get<C extends MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  get<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
-    if (identifier instanceof BinaryTreeNode) callback = (node => node) as C;
+    if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
     // TODO may support finding node by value equal
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
@@ -750,7 +693,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * possible values:
    * @returns The function `isSubtreeBST` returns a boolean value.
    */
-  isSubtreeBST(beginRoot: N, iterationType = this.iterationType): boolean {
+  isSubtreeBST(beginRoot: N | null, iterationType = this.iterationType): boolean {
     // TODO there is a bug
     if (!beginRoot) return true;
 
@@ -805,16 +748,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * start from the root of the tree.
    * @param iterationType - The `iterationType` parameter determines the type of traversal to be
    * performed on the binary tree. It can have two possible values:
-   * @returns The function `subTreeTraverse` returns an array of `MapCallbackReturn<N>`.
+   * @returns The function `subTreeTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
    */
-  subTreeTraverse<C extends MapCallback<N>>(
+  subTreeTraverse<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: BinaryTreeNodeKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof beginRoot === 'number') beginRoot = this.get(beginRoot);
 
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (!beginRoot) return ans;
 
     if (iterationType === IterationType.RECURSIVE) {
@@ -852,16 +795,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * is `null`, an empty array will be returned.
    * @param {IterationType} iterationType - The `iterationType` parameter determines the type of
    * iteration used in the depth-first search algorithm. It can have two possible values:
-   * @returns The function `dfs` returns an array of `MapCallbackReturn<N>` values.
+   * @returns The function `dfs` returns an array of `ReturnType<OneParamCallback<N>>` values.
    */
-  dfs<C extends MapCallback<N>>(
+  dfs<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
     iterationType: IterationType = IterationType.ITERATIVE
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (iterationType === IterationType.RECURSIVE) {
       const _traverse = (node: N) => {
         switch (pattern) {
@@ -930,22 +873,22 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function on each node.
    * @param callback - The `callback` parameter is a function that will be called for each node in the
    * breadth-first search. It takes a node of type `N` as its argument and returns a value of type
-   * `BFSCallbackReturn<N>`. The default value for this parameter is `this._defaultCallbackByKey
+   * `ReturnType<OneParamCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the breadth-first
    * search. It determines from which node the search will begin. If `beginRoot` is `null`, the search
    * will not be performed and an empty array will be returned.
    * @param iterationType - The `iterationType` parameter determines the type of iteration to be used
    * in the breadth-first search (BFS) algorithm. It can have two possible values:
-   * @returns The function `bfs` returns an array of `BFSCallbackReturn<N>[]`.
+   * @returns The function `bfs` returns an array of `ReturnType<OneParamCallback<N>>[]`.
    */
-  bfs<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
+  bfs<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (!beginRoot) return [];
 
-    const ans: BFSCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
 
     if (iterationType === IterationType.RECURSIVE) {
       const queue = new Queue<N>([beginRoot]);
@@ -995,7 +938,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * level in a binary tree. Each inner array contains the return type of the provided callback
    * function `C` applied to the nodes at that level.
    */
-  listLevels<C extends BFSCallback<N> = BFSCallback<N, BinaryTreeNodeKey>>(
+  listLevels<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -1054,7 +997,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
    * algorithm and returns an array of values obtained by applying a callback function to each node.
    * @param callback - The `callback` parameter is a function that will be called on each node in the
-   * tree. It takes a node of type `N` as input and returns a value of type `MapCallbackReturn<N>`. The
+   * tree. It takes a node of type `N` as input and returns a value of type `ReturnType<OneParamCallback<N>>`. The
    * default value for this parameter is `this._defaultCallbackByKey`.
    * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter in the `morris` function
    * determines the order in which the nodes of a binary tree are traversed. It can have one of the
@@ -1062,15 +1005,15 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the Morris
    * traversal. It specifies the root node of the tree from which the traversal should begin. If
    * `beginRoot` is `null`, an empty array will be returned.
-   * @returns The `morris` function returns an array of `MapCallbackReturn<N>` values.
+   * @returns The `morris` function returns an array of `ReturnType<OneParamCallback<N>>` values.
    */
-  morris<C extends MapCallback<N>>(
+  morris<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root
   ): ReturnType<C>[] {
     if (beginRoot === null) return [];
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
 
     let cur: N | null | undefined = beginRoot;
     const _reverseEdge = (node: N | null | undefined) => {
@@ -1149,6 +1092,49 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return ans;
   }
 
+  /**
+   * The above function is an iterator for a binary tree that can be used to traverse the tree in
+   * either an iterative or recursive manner.
+   * @param node - The `node` parameter represents the current node in the binary tree from which the
+   * iteration starts. It is an optional parameter with a default value of `this.root`, which means
+   * that if no node is provided, the iteration will start from the root of the binary tree.
+   * @returns The `*[Symbol.iterator]` method returns a generator object that yields the keys of the
+   * binary tree nodes in a specific order.
+   */
+  * [Symbol.iterator](node = this.root): Generator<BinaryTreeNodeKey, void, undefined> {
+    if (!node) {
+      return;
+    }
+
+    if (this.iterationType === IterationType.ITERATIVE) {
+      const stack: (N | null | undefined)[] = [];
+      let current: N | null | undefined = node;
+
+      while (current || stack.length > 0) {
+        while (current) {
+          stack.push(current);
+          current = current.left;
+        }
+
+        current = stack.pop();
+
+        if (current) yield current.key;
+        if (current) current = current.right;
+      }
+    } else {
+
+      if (node.left) {
+        yield* this[Symbol.iterator](node.left);
+      }
+      yield node.key;
+      if (node.right) {
+        yield* this[Symbol.iterator](node.right);
+      }
+    }
+
+  }
+
+
   /**
    * Swap the data of two nodes in the binary tree.
    * @param {N} srcNode - The source node to swap.
@@ -1177,7 +1163,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * the tree's structure should be restored to its original state to maintain the tree's integrity.
    * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
    */
-  protected _defaultCallbackByKey: DefaultMapCallback<N> = node => node.key;
+  protected _defaultCallbackByKey: OneParamCallback<N, BinaryTreeNodeKey> = node => node.key;
 
   /**
    * The function `_addTo` adds a new node to a binary tree if there is an available position.

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

@@ -5,14 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {
-  BinaryTreeNodeKey,
-  BSTComparator,
-  BSTNodeNested,
-  BSTOptions,
-  MapCallback,
-  MapCallbackReturn
-} from '../../types';
+import type {BinaryTreeNodeKey, BSTComparator, BSTNodeNested, BSTOptions, OneParamCallback} from '../../types';
 import {CP, IterationType} from '../../types';
 import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBinaryTree} from '../../interfaces';
@@ -227,7 +220,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 (`MapCallback<N>`) that determines
+   * value (`BinaryTreeNodeKey`) or a custom callback function (`OneParamCallback<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
@@ -240,8 +233,8 @@ 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 MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  override get<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     beginRoot = this.root,
     iterationType = this.iterationType
@@ -291,8 +284,8 @@ 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 MapCallback<N>>(
-    identifier: ReturnType<C> | N,
+  override getNodes<C extends OneParamCallback<N>>(
+    identifier: ReturnType<C> | null,
     callback: C = this._defaultCallbackByKey as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
@@ -363,16 +356,16 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * (`BinaryTreeNodeKey`), 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 `MapCallbackReturn<N>`.
+   * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<OneParamCallback<N>>`.
    */
-  lesserOrGreaterTraverse<C extends MapCallback<N>>(
+  lesserOrGreaterTraverse<C extends OneParamCallback<N>>(
     callback: C = this._defaultCallbackByKey as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BinaryTreeNodeKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
     if (typeof targetNode === 'number') targetNode = this.get(targetNode);
-    const ans: MapCallbackReturn<N>[] = [];
+    const ans: ReturnType<OneParamCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;
     if (!this.root) return ans;

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

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, MapCallback} from '../../types';
+import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, OneParamCallback} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -274,7 +274,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 MapCallback<N>>(
+  override delete<C extends OneParamCallback<N>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultCallbackByKey as C,
     ignoreCount = false

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

@@ -196,7 +196,7 @@ export abstract class AbstractGraph<
    * @returns a boolean value. It returns true if at least one vertex was successfully removed, and false if no vertices
    * were removed.
    */
-  removeAllVertices(vertices: V[] | VertexKey[]): boolean {
+  removeManyVertices(vertices: V[] | VertexKey[]): boolean {
     const removed: boolean[] = [];
     for (const v of vertices) {
       removed.push(this.deleteVertex(v));

package/src/data-structures/graph/map-graph.ts

@@ -109,9 +109,9 @@ export class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEd
    */
   override createVertex(
     key: VertexKey,
-    val?: V['val'],
     lat: number = this.origin[0],
-    long: number = this.origin[1]
+    long: number = this.origin[1],
+    val?: V['val']
   ): V {
     return new MapVertex(key, lat, long, val) as V;
   }