data-structure-typed 1.20.0 → 1.21.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -356,13 +356,15 @@ import {UndirectedGraph} from 'data-structure-typed';
 </table>
 
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/dfs-pre-order.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/dfs-pre-order.webp?raw=true)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/test-graphs.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/map-graph.webp?raw=true)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/cut-off-trees-for-golf.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/test-graphs.webp?raw=true)
 
-![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/parenthesis-check.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/cut-off-trees-for-golf.webp?raw=true)
+
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/examples/parenthesis-check.webp?raw=true)
 
 
 ## API docs & Examples

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

@@ -54,8 +54,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
     get size(): number;
     private _loopType;
     get loopType(): LoopType;
-    private _isMergeDuplicatedNodeById;
-    get isMergeDuplicatedNodeById(): boolean;
     private _visitedId;
     get visitedId(): BinaryTreeNodeId[];
     private _visitedVal;
@@ -96,16 +94,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @returns The function `add` returns either the inserted node (`N`), `null`, or `undefined`.
      */
     add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val']): N | null | undefined;
-    /**
-     * The function adds a new node to the left or right child of a parent node, updating the size of the tree if
-     * necessary.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
-     * either a node object (`N`) or `null`.
-     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
-     * child.
-     * @returns either the left child node, the right child node, or undefined.
-     */
-    addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
      * The `addMany` function adds multiple nodes to a tree data structure and returns an array of the inserted nodes or
      * null/undefined values.
@@ -285,6 +273,17 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * Space complexity of Iterative DFS equals to recursive DFS which is O(n) because of the stack
      */
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    /**
+     * The function adds a new node to a binary tree if there is an available position.
+     * @param {N | null} newNode - The `newNode` parameter is of type `N | null`, which means it can either be a node of
+     * type `N` or `null`. It represents the node that you want to add to the binary tree.
+     * @param {N} parent - The parent parameter is of type N, which represents a node in a binary tree.
+     * @returns either the left or right child node of the parent node, depending on which child is available for adding
+     * the new node. If a new node is added, the function also updates the size of the binary tree. If neither the left nor
+     * right child is available, the function returns undefined. If the parent node is null, the function also returns
+     * undefined.
+     */
+    protected _addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
      * The function sets the loop type for a protected variable.
      * @param {LoopType} value - The value parameter is of type LoopType.
@@ -310,12 +309,6 @@ export declare abstract class AbstractBinaryTree<N extends AbstractBinaryTreeNod
      * @param {number[]} value - An array of numbers that represents the visited left sum.
      */
     protected _setVisitedLeftSum(value: number[]): void;
-    /**
-     * The function sets the value of a protected property called "_isMergeDuplicatedNodeById".
-     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedNodeById
-     * property should be set to true or false.
-     */
-    protected _setIsDuplicatedVal(value: boolean): void;
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.

package/dist/data-structures/binary-tree/abstract-binary-tree.js

@@ -113,21 +113,14 @@ class AbstractBinaryTree {
         this._root = null;
         this._size = 0;
         this._loopType = types_1.LoopType.ITERATIVE;
-        // TODO this variable may be moved to TreeMultiset
-        this._isMergeDuplicatedNodeById = true;
         this._visitedId = [];
         this._visitedVal = [];
         this._visitedNode = [];
         this._visitedLeftSum = [];
         if (options !== undefined) {
-            const { loopType = types_1.LoopType.ITERATIVE, isMergeDuplicatedNodeById = true } = options;
-            this._isMergeDuplicatedNodeById = isMergeDuplicatedNodeById;
+            const { loopType = types_1.LoopType.ITERATIVE } = options;
             this._loopType = loopType;
         }
-        else {
-            this._isMergeDuplicatedNodeById = true;
-            this._loopType = types_1.LoopType.ITERATIVE;
-        }
         this.clear();
     }
     get root() {
@@ -139,9 +132,6 @@ class AbstractBinaryTree {
     get loopType() {
         return this._loopType;
     }
-    get isMergeDuplicatedNodeById() {
-        return this._isMergeDuplicatedNodeById;
-    }
     get visitedId() {
         return this._visitedId;
     }
@@ -209,7 +199,9 @@ class AbstractBinaryTree {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const inserted = this.addTo(newNode, cur);
+                    if (newNode && cur.id === newNode.id)
+                        return;
+                    const inserted = this._addTo(newNode, cur);
                     if (inserted !== undefined)
                         return inserted;
                     if (cur.left)
@@ -257,41 +249,6 @@ class AbstractBinaryTree {
         }
         return inserted;
     }
-    /**
-     * The function adds a new node to the left or right child of a parent node, updating the size of the tree if
-     * necessary.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
-     * either a node object (`N`) or `null`.
-     * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
-     * child.
-     * @returns either the left child node, the right child node, or undefined.
-     */
-    addTo(newNode, parent) {
-        if (parent) {
-            // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
-            // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
-            if (parent.left === undefined) {
-                parent.left = newNode;
-                if (newNode) {
-                    this._setSize(this.size + 1);
-                }
-                return parent.left;
-            }
-            else if (parent.right === undefined) {
-                parent.right = newNode;
-                if (newNode) {
-                    this._setSize(this.size + 1);
-                }
-                return parent.right;
-            }
-            else {
-                return;
-            }
-        }
-        else {
-            return;
-        }
-    }
     /**
      * The `addMany` function adds multiple nodes to a tree data structure and returns an array of the inserted nodes or
      * null/undefined values.
@@ -306,29 +263,22 @@ class AbstractBinaryTree {
         // TODO not sure addMany not be run multi times
         const inserted = [];
         const map = new Map();
-        if (this.isMergeDuplicatedNodeById) {
-            for (const idOrNode of idsOrNodes)
-                map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
-        }
+        for (const idOrNode of idsOrNodes)
+            map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
         for (let i = 0; i < idsOrNodes.length; i++) {
             const idOrNode = idsOrNodes[i];
-            if (idOrNode instanceof AbstractBinaryTreeNode) {
-                inserted.push(this.add(idOrNode.id, idOrNode.val));
-                continue;
-            }
-            if (idOrNode === null) {
-                inserted.push(this.add(null));
-                continue;
-            }
-            const val = data === null || data === void 0 ? void 0 : data[i];
-            if (this.isMergeDuplicatedNodeById) {
-                if (map.has(idOrNode)) {
-                    inserted.push(this.add(idOrNode, val));
-                    map.delete(idOrNode);
+            if (map.has(idOrNode)) {
+                if (idOrNode instanceof AbstractBinaryTreeNode) {
+                    inserted.push(this.add(idOrNode.id, idOrNode.val));
+                    continue;
                 }
-            }
-            else {
+                if (idOrNode === null) {
+                    inserted.push(this.add(null));
+                    continue;
+                }
+                const val = data === null || data === void 0 ? void 0 : data[i];
                 inserted.push(this.add(idOrNode, val));
+                map.delete(idOrNode);
             }
         }
         return inserted;
@@ -1170,6 +1120,42 @@ class AbstractBinaryTree {
         }
         return this._getResultByPropertyName(nodeOrPropertyName);
     }
+    /**
+     * The function adds a new node to a binary tree if there is an available position.
+     * @param {N | null} newNode - The `newNode` parameter is of type `N | null`, which means it can either be a node of
+     * type `N` or `null`. It represents the node that you want to add to the binary tree.
+     * @param {N} parent - The parent parameter is of type N, which represents a node in a binary tree.
+     * @returns either the left or right child node of the parent node, depending on which child is available for adding
+     * the new node. If a new node is added, the function also updates the size of the binary tree. If neither the left nor
+     * right child is available, the function returns undefined. If the parent node is null, the function also returns
+     * undefined.
+     */
+    _addTo(newNode, parent) {
+        if (parent) {
+            // When all leaf nodes are null, it will no longer be possible to add new entity nodes to this binary tree.
+            // In this scenario, null nodes serve as "sentinel nodes," "virtual nodes," or "placeholder nodes."
+            if (parent.left === undefined) {
+                parent.left = newNode;
+                if (newNode) {
+                    this._setSize(this.size + 1);
+                }
+                return parent.left;
+            }
+            else if (parent.right === undefined) {
+                parent.right = newNode;
+                if (newNode) {
+                    this._setSize(this.size + 1);
+                }
+                return parent.right;
+            }
+            else {
+                return;
+            }
+        }
+        else {
+            return;
+        }
+    }
     /**
      * The function sets the loop type for a protected variable.
      * @param {LoopType} value - The value parameter is of type LoopType.
@@ -1205,14 +1191,6 @@ class AbstractBinaryTree {
     _setVisitedLeftSum(value) {
         this._visitedLeftSum = value;
     }
-    /**
-     * The function sets the value of a protected property called "_isMergeDuplicatedNodeById".
-     * @param {boolean} value - The value parameter is a boolean value that determines whether the isMergeDuplicatedNodeById
-     * property should be set to true or false.
-     */
-    _setIsDuplicatedVal(value) {
-        this._isMergeDuplicatedNodeById = value;
-    }
     /**
      * The function sets the root property of an object to a given value, and if the value is not null, it also sets the
      * parent property of the value to undefined.

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

@@ -68,15 +68,15 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined;
     /**
-     * The function adds a new node to a binary tree as the left or right child of a given parent node.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
-     * either a node object (`N`) or `null`.
+     * The function adds a new node to a binary tree if there is an available slot on the left or right side of the parent
+     * node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to the tree. It can
+     * be either a node object (`N`) or `null`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
      * child.
-     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
-     * `undefined` in certain cases.
+     * @returns The method returns either the `parent.left`, `parent.right`, or `undefined`.
      */
-    addTo(newNode: N | null, parent: N): N | null | undefined;
+    _addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
      * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
      * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects

package/dist/data-structures/binary-tree/tree-multiset.js

@@ -37,7 +37,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * TreeMultiset.
      */
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedNodeById: true }));
+        super(Object.assign({}, options));
         this._count = 0;
     }
     get count() {
@@ -166,15 +166,15 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         return inserted;
     }
     /**
-     * The function adds a new node to a binary tree as the left or right child of a given parent node.
-     * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
-     * either a node object (`N`) or `null`.
+     * The function adds a new node to a binary tree if there is an available slot on the left or right side of the parent
+     * node.
+     * @param {N | null} newNode - The `newNode` parameter represents the node that needs to be added to the tree. It can
+     * be either a node object (`N`) or `null`.
      * @param {N} parent - The `parent` parameter represents the parent node to which the new node will be added as a
      * child.
-     * @returns either the left or right child node that was added to the parent node. It can also return `null` or
-     * `undefined` in certain cases.
+     * @returns The method returns either the `parent.left`, `parent.right`, or `undefined`.
      */
-    addTo(newNode, parent) {
+    _addTo(newNode, parent) {
         if (parent) {
             if (parent.left === undefined) {
                 parent.left = newNode;
@@ -213,30 +213,22 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         // TODO not sure addMany not be run multi times
         const inserted = [];
         const map = new Map();
-        if (this.isMergeDuplicatedNodeById) {
-            for (const idOrNode of idsOrNodes)
-                map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
-        }
+        for (const idOrNode of idsOrNodes)
+            map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 0) + 1);
         for (let i = 0; i < idsOrNodes.length; i++) {
             const idOrNode = idsOrNodes[i];
-            if (idOrNode instanceof TreeMultisetNode) {
-                inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
-                continue;
-            }
-            if (idOrNode === null) {
-                inserted.push(this.add(NaN, null, 0));
-                continue;
-            }
-            const count = this.isMergeDuplicatedNodeById ? map.get(idOrNode) : 1;
-            const val = data === null || data === void 0 ? void 0 : data[i];
-            if (this.isMergeDuplicatedNodeById) {
-                if (map.has(idOrNode)) {
-                    inserted.push(this.add(idOrNode, val, count));
-                    map.delete(idOrNode);
+            if (map.has(idOrNode)) {
+                if (idOrNode instanceof TreeMultisetNode) {
+                    inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
+                    continue;
                 }
-            }
-            else {
-                inserted.push(this.add(idOrNode, val, 1));
+                if (idOrNode === null) {
+                    inserted.push(this.add(NaN, null, 0));
+                    continue;
+                }
+                const val = data === null || data === void 0 ? void 0 : data[i], count = map.get(idOrNode);
+                inserted.push(this.add(idOrNode, val, count));
+                map.delete(idOrNode);
             }
         }
         return inserted;

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

@@ -1,6 +1,6 @@
 import type { DijkstraResult, VertexId } from '../types';
 import { IAbstractGraph } from '../interfaces';
-export declare abstract class AbstractVertex<T = number> {
+export declare abstract class AbstractVertex<T = any> {
     /**
      * The function is a protected constructor that takes an id and an optional value as parameters.
      * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex. It is
@@ -16,7 +16,7 @@ export declare abstract class AbstractVertex<T = number> {
     get val(): T | undefined;
     set val(value: T | undefined);
 }
-export declare abstract class AbstractEdge<T = number> {
+export declare abstract class AbstractEdge<T = any> {
     /**
      * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
      * object.
@@ -46,7 +46,7 @@ export declare abstract class AbstractEdge<T = number> {
      */
     protected _setHashCode(v: string): void;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E extends AbstractEdge<any>> implements IAbstractGraph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex<any> = AbstractVertex<any>, E extends AbstractEdge<any> = AbstractEdge<any>> implements IAbstractGraph<V, E> {
     private _vertices;
     get vertices(): Map<VertexId, V>;
     /**

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

@@ -520,9 +520,8 @@ class AbstractGraph {
         const preMap = new Map(); // predecessor
         const srcVertex = this._getVertex(src);
         const destVertex = dest ? this._getVertex(dest) : null;
-        if (!srcVertex) {
+        if (!srcVertex)
             return null;
-        }
         for (const vertex of vertices) {
             const vertexOrId = vertex[1];
             if (vertexOrId instanceof AbstractVertex)
@@ -532,6 +531,11 @@ class AbstractGraph {
         heap.add({ id: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
+        /**
+         * The function `getPaths` retrieves all paths from vertices to a specified minimum vertex.
+         * @param {V | null} minV - The parameter `minV` is of type `V | null`. It represents the minimum vertex value or
+         * null.
+         */
         const getPaths = (minV) => {
             for (const vertex of vertices) {
                 const vertexOrId = vertex[1];

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

@@ -1,3 +1,4 @@
 export * from './abstract-graph';
 export * from './directed-graph';
 export * from './undirected-graph';
+export * from './map-graph';

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./abstract-graph"), exports);
 __exportStar(require("./directed-graph"), exports);
 __exportStar(require("./undirected-graph"), exports);
+__exportStar(require("./map-graph"), exports);

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

@@ -0,0 +1,79 @@
+import { MapGraphCoordinate, VertexId } from '../types';
+import { DirectedEdge, DirectedGraph, DirectedVertex } from './directed-graph';
+export declare class MapVertex<T = any> extends DirectedVertex<T> {
+    /**
+     * The constructor function initializes an object with an id, latitude, longitude, and an optional value.
+     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex.
+     * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
+     * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
+     * values representing points north of the equator and negative values representing points south of the equator.
+     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
+     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
+     * values ranging from -180 to 180.
+     * @param {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(id: VertexId, lat: number, long: number, val?: T);
+    private _lat;
+    get lat(): number;
+    set lat(value: number);
+    private _long;
+    get long(): number;
+    set long(value: number);
+}
+export declare class MapEdge<T = any> extends DirectedEdge<T> {
+    /**
+     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
+     * value.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src: VertexId, dest: VertexId, weight?: number, val?: T);
+}
+export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E extends MapEdge = MapEdge> extends DirectedGraph<V, E> {
+    /**
+     * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
+     * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
+     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
+     * graph.
+     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
+     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
+     * it will default to `undefined`.
+     */
+    constructor(origin: MapGraphCoordinate, bottomRight?: MapGraphCoordinate);
+    private _origin;
+    get origin(): MapGraphCoordinate;
+    set origin(value: MapGraphCoordinate);
+    private _bottomRight;
+    get bottomRight(): MapGraphCoordinate | undefined;
+    set bottomRight(value: MapGraphCoordinate | undefined);
+    /**
+     * The function creates a new vertex with the given id, value, latitude, and longitude.
+     * @param {VertexId} id - The id parameter is the unique identifier for the vertex. It is of type VertexId, which could
+     * be a string or a number depending on how you define it in your code.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
+     * is of type `V['val']`, which means it should be of the same type as the `val` property of the vertex class `V`.
+     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
+     * position of the vertex on the Earth's surface in the north-south direction.
+     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `V`.
+     */
+    createVertex(id: VertexId, val?: V['val'], lat?: number, long?: number): V;
+    /**
+     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
+     * @param {VertexId} src - The source vertex ID of the edge. It represents the starting point of the edge.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
+     * created.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
+     * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
+     * If the weight is not provided, it can be set to a default value or left undefined.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * depending on the specific implementation of the `MapEdge` class.
+     * @returns a new instance of the `MapEdge` class, casted as type `E`.
+     */
+    createEdge(src: VertexId, dest: VertexId, weight?: number, val?: E['val']): E;
+}

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapGraph = exports.MapEdge = exports.MapVertex = void 0;
+const directed_graph_1 = require("./directed-graph");
+class MapVertex extends directed_graph_1.DirectedVertex {
+    /**
+     * The constructor function initializes an object with an id, latitude, longitude, and an optional value.
+     * @param {VertexId} id - The `id` parameter is of type `VertexId` and represents the identifier of the vertex.
+     * @param {number} lat - The "lat" parameter represents the latitude of a vertex. Latitude is a geographic coordinate
+     * that specifies the north-south position of a point on the Earth's surface. It is measured in degrees, with positive
+     * values representing points north of the equator and negative values representing points south of the equator.
+     * @param {number} long - The "long" parameter represents the longitude of a location. Longitude is a geographic
+     * coordinate that specifies the east-west position of a point on the Earth's surface. It is measured in degrees, with
+     * values ranging from -180 to 180.
+     * @param {T} [val] - The "val" parameter is an optional value of type T. It is not required to be provided when
+     * creating an instance of the class.
+     */
+    constructor(id, lat, long, val) {
+        super(id, val);
+        this._lat = lat;
+        this._long = long;
+    }
+    get lat() {
+        return this._lat;
+    }
+    set lat(value) {
+        this._lat = value;
+    }
+    get long() {
+        return this._long;
+    }
+    set long(value) {
+        this._long = value;
+    }
+}
+exports.MapVertex = MapVertex;
+class MapEdge extends directed_graph_1.DirectedEdge {
+    /**
+     * The constructor function initializes a new instance of a class with the given source, destination, weight, and
+     * value.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for an edge.
+     * @param {number} [weight] - The weight parameter is an optional number that represents the weight of the edge.
+     * @param {T} [val] - The "val" parameter is an optional parameter of type T. It is used to store additional
+     * information or data associated with the edge.
+     */
+    constructor(src, dest, weight, val) {
+        super(src, dest, weight, val);
+    }
+}
+exports.MapEdge = MapEdge;
+class MapGraph extends directed_graph_1.DirectedGraph {
+    /**
+     * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
+     * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the
+     * starting point or reference point of the map graph. It defines the coordinates of the top-left corner of the map
+     * graph.
+     * @param {MapGraphCoordinate} [bottomRight] - The `bottomRight` parameter is an optional parameter of type
+     * `MapGraphCoordinate`. It represents the bottom right coordinate of a map graph. If this parameter is not provided,
+     * it will default to `undefined`.
+     */
+    constructor(origin, bottomRight) {
+        super();
+        this._origin = [0, 0];
+        this._origin = origin;
+        this._bottomRight = bottomRight;
+    }
+    get origin() {
+        return this._origin;
+    }
+    set origin(value) {
+        this._origin = value;
+    }
+    get bottomRight() {
+        return this._bottomRight;
+    }
+    set bottomRight(value) {
+        this._bottomRight = value;
+    }
+    /**
+     * The function creates a new vertex with the given id, value, latitude, and longitude.
+     * @param {VertexId} id - The id parameter is the unique identifier for the vertex. It is of type VertexId, which could
+     * be a string or a number depending on how you define it in your code.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the vertex. It
+     * is of type `V['val']`, which means it should be of the same type as the `val` property of the vertex class `V`.
+     * @param {number} lat - The `lat` parameter represents the latitude of the vertex. It is a number that specifies the
+     * position of the vertex on the Earth's surface in the north-south direction.
+     * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
+     * @returns The method is returning a new instance of the `MapVertex` class, casted as type `V`.
+     */
+    createVertex(id, val, lat = this.origin[0], long = this.origin[1]) {
+        return new MapVertex(id, lat, long, val);
+    }
+    /**
+     * The function creates a new instance of a MapEdge with the given source, destination, weight, and value.
+     * @param {VertexId} src - The source vertex ID of the edge. It represents the starting point of the edge.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex for the edge being
+     * created.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. It
+     * is used to assign a numerical value to the edge, which can be used in algorithms such as shortest path algorithms.
+     * If the weight is not provided, it can be set to a default value or left undefined.
+     * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
+     * depending on the specific implementation of the `MapEdge` class.
+     * @returns a new instance of the `MapEdge` class, casted as type `E`.
+     */
+    createEdge(src, dest, weight, val) {
+        return new MapEdge(src, dest, weight, val);
+    }
+}
+exports.MapGraph = MapGraph;

package/dist/data-structures/interfaces/abstract-binary-tree.d.ts

@@ -22,14 +22,12 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     get visitedVal(): Array<N['val']>;
     get visitedNode(): N[];
     get visitedLeftSum(): number[];
-    get isMergeDuplicatedNodeById(): boolean;
     get root(): N | null;
     get size(): number;
     swapLocation(srcNode: N, destNode: N): N;
     clear(): void;
     isEmpty(): boolean;
     add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined;
-    addTo(newNode: N | null, parent: N): N | null | undefined;
     addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
     fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];