min-heap-typed 1.39.3 → 1.39.5

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -11,7 +11,7 @@ export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
      */
     constructor(key: VertexKey, val?: V);
 }
-export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
+export declare class UndirectedEdge<E = number> extends AbstractEdge<E> {
     /**
      * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
      * value.
@@ -19,21 +19,21 @@ export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
      * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
+     * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
-    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: V);
+    constructor(v1: VertexKey, v2: VertexKey, weight?: number, val?: E);
     private _vertices;
     get vertices(): [VertexKey, VertexKey];
     set vertices(v: [VertexKey, VertexKey]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IGraph<V, E> {
+export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVertex<V> = UndirectedVertex<V>, EO extends UndirectedEdge<E> = UndirectedEdge<E>> extends AbstractGraph<V, E, VO, EO> implements IGraph<V, E, VO, EO> {
     /**
      * The constructor initializes a new Map object to store edges.
      */
     constructor();
-    protected _edges: Map<V, E[]>;
-    get edges(): Map<V, E[]>;
+    protected _edges: Map<VO, EO[]>;
+    get edges(): Map<VO, EO[]>;
     /**
      * The function creates a new vertex with an optional value and returns it.
      * @param {VertexKey} key - The `key` parameter is the unique identifier for the vertex. It is used to distinguish one
@@ -41,9 +41,9 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
      * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
-     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
      */
-    createVertex(key: VertexKey, val?: V['val']): V;
+    createVertex(key: VertexKey, val?: VO['val']): VO;
     /**
      * The function creates an undirected edge between two vertices with an optional weight and value.
      * @param {VertexKey} v1 - The parameter `v1` represents the first vertex of the edge.
@@ -52,76 +52,76 @@ export declare class UndirectedGraph<V extends UndirectedVertex<any> = Undirecte
      * no weight is provided, it defaults to 1.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
-     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
      */
-    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: E['val']): E;
+    createEdge(v1: VertexKey, v2: VertexKey, weight?: number, val?: EO['val']): EO;
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (vertex ID).
-     * @returns an edge (E) or null.
+     * @returns an edge (EO) or null.
      */
-    getEdge(v1: V | null | VertexKey, v2: V | null | VertexKey): E | null;
+    getEdge(v1: VO | null | VertexKey, v2: VO | null | VertexKey): EO | null;
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
-     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
+     * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
      */
-    deleteEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
+    deleteEdgeBetween(v1: VO | VertexKey, v2: VO | VertexKey): EO | null;
     /**
      * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
      */
-    deleteEdge(edge: E): E | null;
+    deleteEdge(edge: EO): EO | null;
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
      * edges connected to that vertex.
      */
-    degreeOf(vertexOrKey: VertexKey | V): number;
+    degreeOf(vertexOrKey: VertexKey | VO): number;
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
-     * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
+     * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
      * @returns an array of edges.
      */
-    edgesOf(vertexOrKey: VertexKey | V): E[];
+    edgesOf(vertexOrKey: VertexKey | VO): EO[];
     /**
      * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
      */
-    edgeSet(): E[];
+    edgeSet(): EO[];
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (V[]).
+     * @returns an array of vertices (VO[]).
      */
-    getNeighbors(vertexOrKey: V | VertexKey): V[];
+    getNeighbors(vertexOrKey: VO | VertexKey): VO[];
     /**
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
      * it returns null.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `null`.
      */
-    getEndsOfEdge(edge: E): [V, V] | null;
+    getEndsOfEdge(edge: EO): [VO, VO] | null;
     /**
      * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
-    protected _addEdgeOnly(edge: E): boolean;
+    protected _addEdgeOnly(edge: EO): boolean;
     /**
      * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
      */
-    protected _setEdges(v: Map<V, E[]>): void;
+    protected _setEdges(v: Map<VO, EO[]>): void;
 }

package/dist/data-structures/graph/undirected-graph.js

@@ -31,7 +31,7 @@ class UndirectedEdge extends abstract_graph_1.AbstractEdge {
      * @param {VertexKey} v2 - The parameter `v2` is a `VertexKey`, which represents the identifier of the second vertex in a
      * graph edge.
      * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
-     * @param {V} [val] - The "val" parameter is an optional parameter of type V. It is used to store a value associated
+     * @param {E} [val] - The "val" parameter is an optional parameter of type E. It is used to store a value associated
      * with the edge.
      */
     constructor(v1, v2, weight, val) {
@@ -64,7 +64,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param [val] - The `val` parameter is an optional value that can be assigned to the vertex. If a value is provided,
      * it will be used as the value of the vertex. If no value is provided, the `key` parameter will be used as the value of
      * the vertex.
-     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `V`.
+     * @returns The method is returning a new instance of the `UndirectedVertex` class, casted as type `VO`.
      */
     createVertex(key, val) {
         return new UndirectedVertex(key, val !== null && val !== void 0 ? val : key);
@@ -77,18 +77,18 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * no weight is provided, it defaults to 1.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type and
      * is used to store additional information or data associated with the edge.
-     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `E`.
+     * @returns a new instance of the `UndirectedEdge` class, which is casted as type `EO`.
      */
     createEdge(v1, v2, weight, val) {
         return new UndirectedEdge(v1, v2, weight !== null && weight !== void 0 ? weight : 1, val);
     }
     /**
      * The function `getEdge` returns the first edge that connects two vertices, or null if no such edge exists.
-     * @param {V | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | null | VertexKey} v1 - The parameter `v1` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (a string or number representing the ID of a vertex).
-     * @param {V | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `V` (vertex
+     * @param {VO | null | VertexKey} v2 - The parameter `v2` represents a vertex or vertex ID. It can be of type `VO` (vertex
      * object), `null`, or `VertexKey` (vertex ID).
-     * @returns an edge (E) or null.
+     * @returns an edge (EO) or null.
      */
     getEdge(v1, v2) {
         var _a;
@@ -104,10 +104,10 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function removes an edge between two vertices in a graph and returns the removed edge.
-     * @param {V | VertexKey} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexKey`).
-     * @param {V | VertexKey} v2 - V | VertexKey - This parameter can be either a vertex object (V) or a vertex ID
+     * @param {VO | VertexKey} v1 - The parameter `v1` represents either a vertex object (`VO`) or a vertex ID (`VertexKey`).
+     * @param {VO | VertexKey} v2 - VO | VertexKey - This parameter can be either a vertex object (VO) or a vertex ID
      * (VertexKey). It represents the second vertex of the edge that needs to be removed.
-     * @returns the removed edge (E) if it exists, or null if either of the vertices (V) does not exist.
+     * @returns the removed edge (EO) if it exists, or null if either of the vertices (VO) does not exist.
      */
     deleteEdgeBetween(v1, v2) {
         const vertex1 = this._getVertex(v1);
@@ -128,8 +128,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The deleteEdge function removes an edge between two vertices in a graph.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The method is returning either the removed edge (of type E) or null if the edge was not found.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The method is returning either the removed edge (of type EO) or null if the edge was not found.
      */
     deleteEdge(edge) {
         return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
@@ -137,7 +137,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
      * The function `degreeOf` returns the degree of a vertex in a graph, which is the number of edges connected to that
      * vertex.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`.
      * @returns The function `degreeOf` returns the degree of a vertex in a graph. The degree of a vertex is the number of
      * edges connected to that vertex.
      */
@@ -153,8 +153,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function returns the edges of a given vertex or vertex ID.
-     * @param {VertexKey | V} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `V`. A `VertexKey` is a
-     * unique identifier for a vertex in a graph, while `V` represents the type of the vertex.
+     * @param {VertexKey | VO} vertexOrKey - The parameter `vertexOrKey` can be either a `VertexKey` or a `VO`. A `VertexKey` is a
+     * unique identifier for a vertex in a graph, while `VO` represents the type of the vertex.
      * @returns an array of edges.
      */
     edgesOf(vertexOrKey) {
@@ -168,7 +168,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "edgeSet" returns an array of unique edges from a set of edges.
-     * @returns The method `edgeSet()` returns an array of type `E[]`.
+     * @returns The method `edgeSet()` returns an array of type `EO[]`.
      */
     edgeSet() {
         const edgeSet = new Set();
@@ -181,9 +181,9 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function "getNeighbors" returns an array of neighboring vertices for a given vertex or vertex ID.
-     * @param {V | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`V`) or a vertex ID
+     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
      * (`VertexKey`).
-     * @returns an array of vertices (V[]).
+     * @returns an array of vertices (VO[]).
      */
     getNeighbors(vertexOrKey) {
         const neighbors = [];
@@ -202,8 +202,8 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     /**
      * The function "getEndsOfEdge" returns the vertices at the ends of an edge if the edge exists in the graph, otherwise
      * it returns null.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
-     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[V, V]` if the edge exists in the
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
+     * @returns The function `getEndsOfEdge` returns an array containing two vertices `[VO, VO]` if the edge exists in the
      * graph. If the edge does not exist, it returns `null`.
      */
     getEndsOfEdge(edge) {
@@ -221,7 +221,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function adds an edge to the graph by updating the adjacency list with the vertices of the edge.
-     * @param {E} edge - The parameter "edge" is of type E, which represents an edge in a graph.
+     * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
     _addEdgeOnly(edge) {
@@ -243,7 +243,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     }
     /**
      * The function sets the edges of a graph.
-     * @param v - A map where the keys are of type V and the values are arrays of type E.
+     * @param v - A map where the keys are of type VO and the values are arrays of type EO.
      */
     _setEdges(v) {
         this._edges = v;

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

@@ -4,7 +4,7 @@
  * @class
  */
 import { SinglyLinkedList } from '../linked-list';
-export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+export declare class SkipQueue<E = any> extends SinglyLinkedList<E> {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = exports.LinkedListQueue = void 0;
+exports.Queue = exports.SkipQueue = void 0;
 /**
  * @license MIT
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 const linked_list_1 = require("../linked-list");
-class LinkedListQueue extends linked_list_1.SinglyLinkedList {
+class SkipQueue extends linked_list_1.SinglyLinkedList {
     /**
      * The enqueue function adds a value to the end of an array.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
@@ -31,7 +31,7 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
         return (_a = this.head) === null || _a === void 0 ? void 0 : _a.val;
     }
 }
-exports.LinkedListQueue = LinkedListQueue;
+exports.SkipQueue = SkipQueue;
 class Queue {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.

package/dist/interfaces/graph.d.ts

@@ -1,5 +1,5 @@
 import { VertexKey } from '../types';
-export interface IGraph<V, E> {
-    createVertex(key: VertexKey, val?: V): V;
-    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
+export interface IGraph<V, E, VO, EO> {
+    createVertex(key: VertexKey, val?: V): VO;
+    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): EO;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.39.3",
+  "version": "1.39.5",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.39.2"
+    "data-structure-typed": "^1.39.5"
   }
 }

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

@@ -71,13 +71,14 @@ export class AVLTree<V = any, N extends AVLTreeNode<V, N> = AVLTreeNode<V, AVLTr
    * @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
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`
+   * `((node: N) => node.key)`
    * @returns The method is returning an array of `BinaryTreeDeletedResult<N>` objects.
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultCallbackByKey as C
+    callback: C = ((node: N) => node.key) as C
   ): BinaryTreeDeletedResult<N>[] {
+    if ((identifier as any) instanceof AVLTreeNode) callback = (node => node) as C;
     const deletedResults = super.delete(identifier, callback);
     for (const {needBalanced} of deletedResults) {
       if (needBalanced) {

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

@@ -217,7 +217,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     }
 
     const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.get(key, this._defaultCallbackByKey) : undefined;
+    const existNode = key !== undefined ? this.get(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
       if (existNode) {
@@ -296,11 +296,11 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`, which
+   * `((node: N) => node.key)`, which
    */
   delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C
+    callback: C = ((node: N) => node.key) as C
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
@@ -487,7 +487,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   getNodes<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
-    callback: C,
+    callback?: C,
     onlyOne?: boolean,
     beginRoot?: N | null,
     iterationType?: IterationType
@@ -495,7 +495,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
 
   getNodes<C extends BTNCallback<N, N>>(
     identifier: N | null,
-    callback: C,
+    callback?: C,
     onlyOne?: boolean,
     beginRoot?: N | null,
     iterationType?: IterationType
@@ -518,7 +518,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @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
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`, which
+   * `((node: N) => node.key)`, which
    * @param [onlyOne=false] - A boolean value indicating whether to stop searching after finding the
    * first node that matches the identifier. If set to true, the function will return an array with
    * only one element (or an empty array if no matching node is found). If set to false (default), the
@@ -532,7 +532,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -600,7 +600,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired criteria. It takes a node as input and returns a boolean value indicating
    * whether the node matches the criteria or not. The default callback function
-   * `this._defaultCallbackByKey` is used if no callback function is
+   * `((node: N) => node.key)` is used if no callback function is
    * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
    * the node from which the search should begin. By default, it is set to `this.root`, which means the
    * search will start from the root node of the binary tree. However, you can provide a different node
@@ -611,7 +611,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): boolean {
@@ -649,7 +649,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @param callback - The `callback` parameter is a function that is used to determine whether a node
    * matches the desired criteria. It takes a node as input and returns a boolean value indicating
    * whether the node matches the criteria or not. The default callback function
-   * (`this._defaultCallbackByKey`) is used if no callback function is
+   * (`((node: N) => node.key)`) is used if no callback function is
    * @param beginRoot - The `beginRoot` parameter is the starting point for the search. It specifies
    * the root node from which the search should begin.
    * @param iterationType - The `iterationType` parameter specifies the type of iteration to be
@@ -658,7 +658,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    */
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -824,7 +824,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `subTreeTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
   subTreeTraverse<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -860,7 +860,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function on each node according to a specified order pattern.
    * @param callback - The `callback` parameter is a function that will be called on each node during
    * the depth-first search traversal. It takes a node as input and returns a value. The default value
-   * is `this._defaultCallbackByKey`, which is a callback function defined elsewhere in the code.
+   * is `((node: N) => node.key)`, which is a callback function defined elsewhere in the code.
    * @param {DFSOrderPattern} [pattern=in] - The `pattern` parameter determines the order in which the
    * nodes are visited during the depth-first search. There are three possible values for `pattern`:
    * @param {N | null} beginRoot - The `beginRoot` parameter is the starting node for the depth-first
@@ -871,7 +871,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `dfs` returns an array of `ReturnType<BTNCallback<N>>` values.
    */
   dfs<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root,
     iterationType: IterationType = IterationType.ITERATIVE
@@ -946,7 +946,7 @@ 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
-   * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `this._defaultCallbackByKey
+   * `ReturnType<BTNCallback<N>>`. The default value for this parameter is `((node: N) => node.key)
    * @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.
@@ -955,7 +955,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The function `bfs` returns an array of `ReturnType<BTNCallback<N>>[]`.
    */
   bfs<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -1012,7 +1012,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * function `C` applied to the nodes at that level.
    */
   listLevels<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[][] {
@@ -1071,7 +1071,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * 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 `ReturnType<BTNCallback<N>>`. The
-   * default value for this parameter is `this._defaultCallbackByKey`.
+   * default value for this parameter is `((node: N) => node.key)`.
    * @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
    * following values:
@@ -1081,7 +1081,7 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
    * @returns The `morris` function returns an array of `ReturnType<BTNCallback<N>>` values.
    */
   morris<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: N | null = this.root
   ): ReturnType<C>[] {
@@ -1226,15 +1226,6 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     return destNode;
   }
 
-  /**
-   * Time complexity is O(n)
-   * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-   * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-   * 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: BTNCallback<N, BTNKey> = node => node.key;
-
   /**
    * The function `_addTo` adds a new node to a binary tree if there is an available position.
    * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -234,7 +234,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   override get<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
     iterationType = this.iterationType
   ): N | null {
@@ -270,7 +270,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * 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
-   * included in the result. The default value for `callback` is `this._defaultCallbackByKey`, which is
+   * included in the result. The default value for `callback` is `((node: N) => node.key)`, which is
    * a
    * @param [onlyOne=false] - A boolean value indicating whether to stop the traversal after finding
    * the first node that matches the nodeProperty. If set to true, the function will return an array
@@ -285,7 +285,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    */
   override getNodes<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     onlyOne = false,
     beginRoot: N | null = this.root,
     iterationType = this.iterationType
@@ -303,7 +303,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
 
         if (!cur.left && !cur.right) return;
         // TODO potential bug
-        if (callback === this._defaultCallbackByKey) {
+        if (callback === ((node: N) => node.key)) {
           if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && _traverse(cur.left);
           if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && _traverse(cur.right);
         } else {
@@ -324,7 +324,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
             if (onlyOne) return ans;
           }
           // TODO potential bug
-          if (callback === this._defaultCallbackByKey) {
+          if (callback === ((node: N) => node.key)) {
             if (this._compare(cur.key, identifier as number) === CP.gt) cur.left && queue.push(cur.left);
             if (this._compare(cur.key, identifier as number) === CP.lt) cur.right && queue.push(cur.right);
           } else {
@@ -358,7 +358,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns The function `lesserOrGreaterTraverse` returns an array of `ReturnType<BTNCallback<N>>`.
    */
   lesserOrGreaterTraverse<C extends BTNCallback<N>>(
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     lesserOrGreater: CP = CP.lt,
     targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType

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

@@ -268,7 +268,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @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
    * included in the result. The `callback` parameter has a default value of
-   * `this._defaultCallbackByKey`
+   * `((node: N) => node.key)`
    * @param [ignoreCount=false] - A boolean flag indicating whether to ignore the count of the node
    * being deleted. If set to true, the count of the node will not be considered and the node will be
    * deleted regardless of its count. If set to false (default), the count of the node will be
@@ -277,7 +277,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    */
   override delete<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
-    callback: C = this._defaultCallbackByKey as C,
+    callback: C = ((node: N) => node.key) as C,
     ignoreCount = false
   ): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];