data-structure-typed 1.18.7 → 1.18.8

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

@@ -5,11 +5,11 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, RecursiveBSTNode } from '../types';
-import { BinaryTreeDeletedResult, BSTOptions, CP } from '../types';
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested } from '../types';
+import { BSTOptions, CP } from '../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../interfaces';
-export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBSTNode<T>> extends BinaryTreeNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
+export declare class BSTNode<T = any, FAMILY extends BSTNode<T, FAMILY> = BSTNodeNested<T>> extends BinaryTreeNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
     /**
      * The function creates a new binary search tree node with the specified id, value, and count.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier for the binary tree node. It is used to uniquely
@@ -22,7 +22,7 @@ export declare class BSTNode<T, FAMILY extends BSTNode<T, FAMILY> = RecursiveBST
      */
     createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
-export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BinaryTree<N> implements IBST<N> {
+export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**
      * The constructor function accepts an optional options object and sets the comparator property if provided.
      * @param [options] - An optional object that can contain the following properties:
@@ -51,7 +51,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * inserted once.
      * @returns The method `add` returns a `N` object or `null`.
      */
-    add(id: BinaryTreeNodeId, val: N['val'] | null, count?: number): N | null;
+    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null;
     /**
      * The `get` function returns the first node in a binary search tree that matches the given property value or name.
      * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
@@ -71,17 +71,6 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * there are no nodes in
      */
     lastKey(): BinaryTreeNodeId;
-    /**
-     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
-     * the deleted node and any nodes that need to be balanced.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
-     * from the binary search tree.
-     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
-     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
-     * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<N>` objects.
-     */
-    remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
      * option to specify the property name and whether to return only one node.
@@ -97,16 +86,15 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      */
     getNodes(nodeProperty: BinaryTreeNodeId | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
     /**
-     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
-     * a binary search tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
-     * calculate the lesser sum.
+     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a lesser value
+     * than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-     * binary search tree that have a property value lesser than the given `id`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in a binary
+     * tree that have a lesser value than the specified `beginNode` based on the specified `propertyName`.
      */
-    lesserSum(id: BinaryTreeNodeId, propertyName?: BinaryTreeNodePropertyName): number;
+    lesserSum(beginNode: N | BinaryTreeNodeId | null, propertyName?: BinaryTreeNodePropertyName): number;
     /**
      * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
      * that have a greater value than a given node.
@@ -119,7 +107,7 @@ export declare class BST<N extends BSTNode<N['val'], N> = BSTNode<number>> exten
      * defaults to 'id'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
+    allGreaterNodesAdd(node: N | BinaryTreeNodeId | null, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     /**
      * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
      * recursive or iterative approach.

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

@@ -50,7 +50,7 @@ var BSTNode = /** @class */ (function (_super) {
      * @returns The method is returning a new instance of the BSTNode class, casted as the FAMILY type.
      */
     BSTNode.prototype.createNode = function (id, val, count) {
-        return new BSTNode(id, (val === undefined ? id : val), count);
+        return new BSTNode(id, val, count);
     };
     return BSTNode;
 }(binary_tree_1.BinaryTreeNode));
@@ -83,7 +83,7 @@ var BST = /** @class */ (function (_super) {
      * @returns a new instance of the BSTNode class, casted as type N.
      */
     BST.prototype.createNode = function (id, val, count) {
-        return new BSTNode(id, val === undefined ? id : val, count);
+        return new BSTNode(id, val, count);
     };
     /**
      * The `add` function inserts a new node into a binary search tree, updating the count and value of an existing node if
@@ -127,7 +127,6 @@ var BST = /** @class */ (function (_super) {
                         if (cur.left === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = types_1.FamilyPosition.LEFT;
                             }
                             //Add to the left of the current node
                             cur.left = newNode;
@@ -147,7 +146,6 @@ var BST = /** @class */ (function (_super) {
                         if (cur.right === undefined) {
                             if (newNode) {
                                 newNode.parent = cur;
-                                newNode.familyPosition = types_1.FamilyPosition.RIGHT;
                             }
                             //Add to the right of the current node
                             cur.right = newNode;
@@ -201,67 +199,6 @@ var BST = /** @class */ (function (_super) {
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
     };
-    /**
-     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
-     * the deleted node and any nodes that need to be balanced.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
-     * from the binary search tree.
-     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
-     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
-     * set to false or not provided, the count of the node will be taken into account and the
-     * @returns an array of `BSTDeletedResult<N>` objects.
-     */
-    BST.prototype.remove = function (id, ignoreCount) {
-        var bstDeletedResult = [];
-        if (!this.root)
-            return bstDeletedResult;
-        var curr = this.get(id);
-        if (!curr)
-            return bstDeletedResult;
-        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        var needBalanced = null, orgCurrent = curr;
-        if (curr.count > 1 && !ignoreCount) {
-            curr.count--;
-            this._setCount(this.count - 1);
-        }
-        else {
-            if (!curr.left) {
-                if (!parent) {
-                    if (curr.right !== undefined)
-                        this._setRoot(curr.right);
-                }
-                else {
-                    switch (curr.familyPosition) {
-                        case types_1.FamilyPosition.LEFT:
-                            parent.left = curr.right;
-                            break;
-                        case types_1.FamilyPosition.RIGHT:
-                            parent.right = curr.right;
-                            break;
-                    }
-                    needBalanced = parent;
-                }
-            }
-            else {
-                var leftSubTreeMax = curr.left ? this.getRightMost(curr.left) : null;
-                if (leftSubTreeMax) {
-                    var parentOfLeftSubTreeMax = leftSubTreeMax.parent;
-                    orgCurrent = curr.swapLocation(leftSubTreeMax);
-                    if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeMax)
-                            parentOfLeftSubTreeMax.right = leftSubTreeMax.left;
-                        else
-                            parentOfLeftSubTreeMax.left = leftSubTreeMax.left;
-                        needBalanced = parentOfLeftSubTreeMax;
-                    }
-                }
-            }
-            this._setSize(this.size - 1);
-            this._setCount(this.count - curr.count);
-        }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
-        return bstDeletedResult;
-    };
     /**
      * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
      * option to specify the property name and whether to return only one node.
@@ -324,20 +261,24 @@ var BST = /** @class */ (function (_super) {
     };
     // --- start additional functions
     /**
-     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
-     * a binary search tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
-     * calculate the lesser sum.
+     * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a lesser value
+     * than a given node.
+     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
-     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
-     * binary search tree that have a property value lesser than the given `id`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in a binary
+     * tree that have a lesser value than the specified `beginNode` based on the specified `propertyName`.
      */
-    BST.prototype.lesserSum = function (id, propertyName) {
+    BST.prototype.lesserSum = function (beginNode, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof beginNode === 'number')
+            beginNode = this.get(beginNode, 'id');
+        if (!beginNode)
+            return 0;
         if (!this.root)
             return 0;
+        var id = beginNode.id;
         var getSumByPropertyName = function (cur) {
             var needSum;
             switch (propertyName) {
@@ -426,6 +367,11 @@ var BST = /** @class */ (function (_super) {
     BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        if (typeof node === 'number')
+            node = this.get(node, 'id');
+        if (!node)
+            return false;
+        var id = node.id;
         if (!this.root)
             return false;
         var _sumByPropertyName = function (cur) {
@@ -443,7 +389,7 @@ var BST = /** @class */ (function (_super) {
         };
         if (this.loopType === types_1.LoopType.RECURSIVE) {
             var _traverse_3 = function (cur) {
-                var compared = _this._compare(cur.id, node.id);
+                var compared = _this._compare(cur.id, id);
                 _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;

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

@@ -1,8 +1,8 @@
-import { BinaryTreeNodeId, RBColor, RBTreeOptions } from '../types';
+import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../types';
 import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
 import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<T, FAMILY extends RBTreeNode<T, FAMILY>> extends BSTNode<T, FAMILY> implements IRBTreeNode<T, FAMILY> {
-    constructor(id: number, val: T, count?: number);
+export declare class RBTreeNode<T = any, FAMILY extends RBTreeNode<T, FAMILY> = RBTreeNodeNested<T>> extends BSTNode<T, FAMILY> implements IRBTreeNode<T, FAMILY> {
+    constructor(id: BinaryTreeNodeId, val?: T, count?: number);
     private _color;
     get color(): RBColor;
     set color(value: RBColor);
@@ -16,12 +16,12 @@ export declare class RBTreeNode<T, FAMILY extends RBTreeNode<T, FAMILY>> extends
      * node.
      * @returns The method is returning a new instance of the RBTreeNode class, casted as a FAMILY type.
      */
-    createNode(id: BinaryTreeNodeId, val?: T | null, count?: number): FAMILY;
+    createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
-export declare class RBTree<N extends RBTreeNode<N['val'], N>> extends BST<N> implements IRBTree<N> {
+export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
     constructor(options?: RBTreeOptions);
     createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
-    insert(id: number, val: N | null): void;
+    insert(id: number, val?: N | null): void;
     private leftRotate;
     private rightRotate;
     private insertFixup;

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BST, BSTNode } from './bst';
-import type { BinaryTreeNodeId, RecursiveTreeMultiSetNode, TreeMultiSetOptions } from '../types';
-import { IBST, IBSTNode } from '../interfaces';
-export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMILY> = RecursiveTreeMultiSetNode<T>> extends BSTNode<T, FAMILY> implements IBSTNode<T, FAMILY> {
+import type { BinaryTreeNodeId, TreeMultiSetNodeNested, TreeMultiSetOptions } from '../types';
+import { ITreeMultiSet, ITreeMultiSetNode } from '../interfaces';
+import { AVLTree, AVLTreeNode } from './avl-tree';
+export declare class TreeMultiSetNode<T = any, FAMILY extends TreeMultiSetNode<T, FAMILY> = TreeMultiSetNodeNested<T>> extends AVLTreeNode<T, FAMILY> implements ITreeMultiSetNode<T, FAMILY> {
     /**
      * The function creates a new node in a binary tree with an optional value and count.
      * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
@@ -22,9 +22,9 @@ export declare class TreeMultiSetNode<T, FAMILY extends TreeMultiSetNode<T, FAMI
     createNode(id: BinaryTreeNodeId, val?: T, count?: number): FAMILY;
 }
 /**
- * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiSet and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiSet<N extends BSTNode<N['val'], N> = BSTNode<number>> extends BST<N> implements IBST<N> {
+export declare class TreeMultiSet<N extends TreeMultiSetNode<N['val'], N> = TreeMultiSetNode> extends AVLTree<N> implements ITreeMultiSet<N> {
     constructor(options?: TreeMultiSetOptions);
     /**
      * The function creates a new BSTNode with the given id, value, and count.

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

@@ -27,14 +27,7 @@ var __assign = (this && this.__assign) || function () {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = exports.TreeMultiSetNode = void 0;
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-var bst_1 = require("./bst");
+var avl_tree_1 = require("./avl-tree");
 var TreeMultiSetNode = /** @class */ (function (_super) {
     __extends(TreeMultiSetNode, _super);
     function TreeMultiSetNode() {
@@ -51,18 +44,18 @@ var TreeMultiSetNode = /** @class */ (function (_super) {
      * @returns The method is returning a new instance of the TreeMultiSetNode class, casted as the FAMILY type.
      */
     TreeMultiSetNode.prototype.createNode = function (id, val, count) {
-        return new TreeMultiSetNode(id, (val === undefined ? id : val), count);
+        return new TreeMultiSetNode(id, val, count);
     };
     return TreeMultiSetNode;
-}(bst_1.BSTNode));
+}(avl_tree_1.AVLTreeNode));
 exports.TreeMultiSetNode = TreeMultiSetNode;
 /**
- * The only distinction between a TreeMultiSet and a BST lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultiSet and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
 var TreeMultiSet = /** @class */ (function (_super) {
     __extends(TreeMultiSet, _super);
     function TreeMultiSet(options) {
-        return _super.call(this, __assign(__assign({}, options), { isDuplicatedVal: true })) || this;
+        return _super.call(this, __assign(__assign({}, options), { isMergeDuplicatedVal: true })) || this;
     }
     /**
      * The function creates a new BSTNode with the given id, value, and count.
@@ -74,8 +67,8 @@ var TreeMultiSet = /** @class */ (function (_super) {
      * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
      */
     TreeMultiSet.prototype.createNode = function (id, val, count) {
-        return new TreeMultiSetNode(id, val === undefined ? id : val, count);
+        return new TreeMultiSetNode(id, val, count);
     };
     return TreeMultiSet;
-}(bst_1.BST));
+}(avl_tree_1.AVLTree));
 exports.TreeMultiSet = TreeMultiSet;

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

@@ -50,8 +50,8 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      */
     hasVertex(vertexOrId: V | VertexId): boolean;
     abstract getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    createAddVertex(id: VertexId, val?: V['val']): boolean;
-    addVertex(newVertex: V): boolean;
+    addVertex(vertex: V): boolean;
+    addVertex(id: VertexId, val?: V['val']): boolean;
     /**
      * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a vertex object (`V`) or a vertex ID
@@ -80,8 +80,8 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * vertices `v1` and `v2`, and `false` otherwise.
      */
     hasEdge(v1: VertexId | V, v2: VertexId | V): boolean;
-    createAddEdge(src: V | VertexId, dest: V | VertexId, weight: number, val: E['val']): boolean;
-    abstract addEdge(edge: E): boolean;
+    addEdge(edge: E): boolean;
+    addEdge(src: V | VertexId, dest: V | VertexId, weight?: number, val?: E['val']): boolean;
     /**
      * The function sets the weight of an edge between two vertices in a graph.
      * @param {VertexId | V} srcOrId - The `srcOrId` parameter can be either a `VertexId` or a `V` object. It represents
@@ -205,11 +205,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         min: number;
         minPath: V[];
     };
-    /**
-     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
-     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -254,6 +249,13 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         SCCs: Map<number, V[]>;
         cycles: Map<number, V[]>;
     };
+    /**
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
+     */
+    protected _addVertexOnly(newVertex: V): boolean;
+    protected abstract _addEdgeOnly(edge: E): boolean;
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs

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

@@ -149,17 +149,14 @@ var AbstractGraph = /** @class */ (function () {
     AbstractGraph.prototype.hasVertex = function (vertexOrId) {
         return this._vertices.has(this._getVertexId(vertexOrId));
     };
-    AbstractGraph.prototype.createAddVertex = function (id, val) {
-        var newVertex = this.createVertex(id, val);
-        return this.addVertex(newVertex);
-    };
-    AbstractGraph.prototype.addVertex = function (newVertex) {
-        if (this.hasVertex(newVertex)) {
-            return false;
-            // throw (new Error('Duplicated vertex id is not allowed'));
+    AbstractGraph.prototype.addVertex = function (idOrVertex, val) {
+        if (idOrVertex instanceof AbstractVertex) {
+            return this._addVertexOnly(idOrVertex);
+        }
+        else {
+            var newVertex = this.createVertex(idOrVertex, val);
+            return this._addVertexOnly(newVertex);
         }
-        this._vertices.set(newVertex.id, newVertex);
-        return true;
     };
     /**
      * The `removeVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
@@ -209,13 +206,25 @@ var AbstractGraph = /** @class */ (function () {
         var edge = this.getEdge(v1, v2);
         return !!edge;
     };
-    AbstractGraph.prototype.createAddEdge = function (src, dest, weight, val) {
-        if (src instanceof AbstractVertex)
-            src = src.id;
-        if (dest instanceof AbstractVertex)
-            dest = dest.id;
-        var newEdge = this.createEdge(src, dest, weight, val);
-        return this.addEdge(newEdge);
+    AbstractGraph.prototype.addEdge = function (srcOrEdge, dest, weight, val) {
+        if (srcOrEdge instanceof AbstractEdge) {
+            return this._addEdgeOnly(srcOrEdge);
+        }
+        else {
+            if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
+                if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest)))
+                    return false;
+                if (srcOrEdge instanceof AbstractVertex)
+                    srcOrEdge = srcOrEdge.id;
+                if (dest instanceof AbstractVertex)
+                    dest = dest.id;
+                var newEdge = this.createEdge(srcOrEdge, dest, weight, val);
+                return this._addEdgeOnly(newEdge);
+            }
+            else {
+                throw new Error('dest must be a Vertex or vertex id while srcOrEdge is an Edge');
+            }
+        }
     };
     /**
      * The function sets the weight of an edge between two vertices in a graph.
@@ -884,11 +893,6 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { hasNegativeCycle: hasNegativeCycle, distMap: distMap, preMap: preMap, paths: paths, min: min, minPath: minPath };
     };
-    /**
-     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
-     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -1058,6 +1062,19 @@ var AbstractGraph = /** @class */ (function () {
         }
         return { dfnMap: dfnMap, lowMap: lowMap, bridges: bridges, articulationPoints: articulationPoints, SCCs: SCCs, cycles: cycles };
     };
+    /**
+     * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
+     * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edges.
+     * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(V^3), where V is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
+     */
+    AbstractGraph.prototype._addVertexOnly = function (newVertex) {
+        if (this.hasVertex(newVertex)) {
+            return false;
+            // throw (new Error('Duplicated vertex id is not allowed'));
+        }
+        this._vertices.set(newVertex.id, newVertex);
+        return true;
+    };
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs

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

@@ -63,14 +63,6 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @returns a E object or null.
      */
     getEdge(srcOrId: V | null | VertexId, destOrId: V | null | VertexId): E | null;
-    /**
-     * The `addEdge` function adds a directed edge to a graph if the source and destination vertices exist.
-     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
-     * contains two properties:
-     * @returns The method `addEdge` returns a boolean value. It returns `true` if the edge was successfully added to the
-     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
-     */
-    addEdge(edge: E): boolean;
     /**
      * The `removeEdgeBetween` function removes an edge between two vertices in a directed graph and returns the removed
      * edge, or null if the edge was not found.
@@ -164,18 +156,19 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      */
     getDestinations(vertex: V | VertexId | null): V[];
     /**
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of `V` or `VertexId` objects in
-     * topological order, or `null` if there is a cycle in the graph.
+     * The `topologicalSort` function performs a topological sort on a graph and returns an array of vertices or vertex IDs
+     * in the sorted order, or null if the graph contains a cycle.
+     * @param {'vertex' | 'id'} [propertyName] - The `propertyName` parameter is an optional parameter that specifies the
+     * property to use for sorting the vertices. It can have two possible values: 'vertex' or 'id'. If 'vertex' is
+     * specified, the vertices themselves will be used for sorting. If 'id' is specified, the ids of
+     * @returns an array of vertices or vertex IDs in topological order, or null if there is a cycle in the graph.
      */
-    topologicalSort(): Array<V | VertexId> | null;
+    topologicalSort(propertyName?: 'vertex' | 'id'): Array<V | VertexId> | null;
     /**
      * The `edgeSet` function returns an array of all directed edges in the graph.
      * @returns The `edgeSet()` method returns an array of `E` objects.
      */
     edgeSet(): E[];
-    /**--- start find cycles --- */
     /**
      * The function `getNeighbors` returns an array of neighboring vertices of a given vertex in a directed graph.
      * @param {V | VertexId} vertexOrId - The parameter `vertexOrId` can be either a `V`
@@ -183,7 +176,7 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * @returns an array of DirectedVertex objects.
      */
     getNeighbors(vertexOrId: V | VertexId): V[];
-    /**--- end find cycles --- */
+    /**--- start find cycles --- */
     /**
      * The function "getEndsOfEdge" returns the source and destination vertices of a directed edge if it exists in the
      * graph, otherwise it returns null.
@@ -192,6 +185,15 @@ export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVerte
      * not exist in the graph.
      */
     getEndsOfEdge(edge: E): [V, V] | null;
+    /**--- end find cycles --- */
+    /**
+     * The `_addEdgeOnly` function adds a directed edge to a graph if the source and destination vertices exist.
+     * @param edge - The parameter `edge` is of type `E`, which represents a directed edge in a graph. It
+     * contains two properties:
+     * @returns The method `_addEdgeOnly` returns a boolean value. It returns `true` if the edge was successfully added to the
+     * graph, and `false` if either the source or destination vertex of the edge is not present in the graph.
+     */
+    protected _addEdgeOnly(edge: E): boolean;
     protected _setOutEdgeMap(value: Map<V, E[]>): void;
     protected _setInEdgeMap(value: Map<V, E[]>): void;
 }