min-heap-typed 1.50.0 → 1.50.2

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

@@ -9,7 +9,7 @@ import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEnt
 import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
+export declare class TreeMultimapNode<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
     count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
@@ -26,44 +26,43 @@ export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNo
 /**
  * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
-    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, N>>, options?: TreeMultimapOptions<K>);
+export declare class TreeMultimap<K = any, V = any, NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, NODE, TREE> = TreeMultimap<K, V, NODE, TreeMultimapNested<K, V, NODE>>> extends AVLTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+    constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: TreeMultimapOptions<K>);
     private _count;
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key: K, value?: V, count?: number): N;
+    createNode(key: K, value?: V, count?: number): NODE;
     createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
      * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `N` or `undefined`.
+     * @returns a node of type `NODE` or `undefined`.
      */
-    exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): N | undefined;
+    keyValueOrEntryToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N;
+    isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n)
@@ -81,47 +80,13 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * @returns The method is returning either the newly inserted node or `undefined` if the insertion
      * was not successful.
      */
-    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
-     * structure.
-     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
-     * either keys, nodes, or entries.
-     * @returns The method is returning an array of type `N | undefined`.
-     */
-    addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>): boolean[];
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
-     */
-    perfectlyBalance(iterationType?: IterationType): boolean;
-    /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
@@ -137,9 +102,9 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * 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
      * decremented by 1 and
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
-    delete<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<N>[];
+    delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback?: C, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -151,6 +116,22 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType?: IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -165,13 +146,13 @@ export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K
     clone(): TREE;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined;
-    protected _replaceNode(oldNode: N, newNode: N): N;
+    protected _swapProperties(srcNode: BSTNKeyOrNode<K, NODE>, destNode: BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    protected _replaceNode(oldNode: NODE, newNode: NODE): NODE;
 }

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

@@ -40,7 +40,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
-     * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
+     * @param {NODE} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
@@ -52,17 +52,17 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return new TreeMultimap([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
     }
     /**
-     * The function `exemplarToNode` converts an keyOrNodeOrEntry object into a node object.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`, which means it
+     * The function `keyValueOrEntryToNode` converts an keyOrNodeOrEntry object into a node object.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`, which means it
      * can be one of the following:
      * @param {V} [value] - The `value` parameter is an optional argument that represents the value
      * associated with the node. It is of type `V`, which can be any data type. If no value is provided,
      * it defaults to `undefined`.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the value should be added to the node. If not provided, it defaults to 1.
-     * @returns a node of type `N` or `undefined`.
+     * @returns a node of type `NODE` or `undefined`.
      */
-    exemplarToNode(keyOrNodeOrEntry, value, count = 1) {
+    keyValueOrEntryToNode(keyOrNodeOrEntry, value, count = 1) {
         let node;
         if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
             return;
@@ -89,7 +89,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, N>`.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
      * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
      * class.
      */
@@ -99,7 +99,6 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
      * Time Complexity: O(log n)
@@ -118,7 +117,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * was not successful.
      */
     add(keyOrNodeOrEntry, value, count = 1) {
-        const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
+        const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
         if (newNode === undefined)
             return false;
         const orgNodeCount = (newNode === null || newNode === void 0 ? void 0 : newNode.count) || 0;
@@ -129,82 +128,11 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         return true;
     }
     /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     * logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity. constant space, as it doesn't use additional data structures that scale with input size.
-     */
-    /**
-     * Time Complexity: O(k log n)
-     * Space Complexity: O(1)
-     *
-     * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
-     * structure.
-     * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
-     * either keys, nodes, or entries.
-     * @returns The method is returning an array of type `N | undefined`.
-     */
-    addMany(keysOrNodesOrEntries) {
-        return super.addMany(keysOrNodesOrEntries);
-    }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree. This is because the method calls the add method for each node. linear space, as it creates an array to store the sorted nodes.
-     */
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
-     * tree using either a recursive or iterative approach.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when building the balanced binary search tree. It can have two possible
-     * values:
-     * @returns a boolean value.
-     */
-    perfectlyBalance(iterationType = this.iterationType) {
-        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
-        if (sorted.length < 1)
-            return false;
-        this.clear();
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const buildBalanceBST = (l, r) => {
-                if (l > r)
-                    return;
-                const m = l + Math.floor((r - l) / 2);
-                const midNode = sorted[m];
-                this.add(midNode.key, midNode.value, midNode.count);
-                buildBalanceBST(l, m - 1);
-                buildBalanceBST(m + 1, r);
-            };
-            buildBalanceBST(0, n - 1);
-            return true;
-        }
-        else {
-            const stack = [[0, n - 1]];
-            while (stack.length > 0) {
-                const popped = stack.pop();
-                if (popped) {
-                    const [l, r] = popped;
-                    if (l <= r) {
-                        const m = l + Math.floor((r - l) / 2);
-                        const midNode = sorted[m];
-                        this.add(midNode.key, midNode.value, midNode.count);
-                        stack.push([m + 1, r]);
-                        stack.push([l, m - 1]);
-                    }
-                }
-            }
-            return true;
-        }
-    }
-    /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
-     * logarithmic time for each insertion, where "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted. This is because the method iterates through the keys and calls the add method for each. constant space, as it doesn't use additional data structures that scale with input size.
      */
     /**
-     * Time Complexity: O(k log n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The `delete` function in TypeScript is used to remove a node from a binary tree, taking into
@@ -220,7 +148,7 @@ class TreeMultimap extends avl_tree_1.AVLTree {
      * 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
      * decremented by 1 and
-     * @returns an array of `BinaryTreeDeleteResult<N>`.
+     * @returns an array of `BinaryTreeDeleteResult<NODE>`.
      */
     delete(identifier, callback = this._defaultOneParamCallback, ignoreCount = false) {
         var _a;
@@ -294,6 +222,57 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         super.clear();
         this._count = 0;
     }
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     */
+    /**
+     * Time Complexity: O(n log n)
+     * Space Complexity: O(log n)
+     *
+     * The `perfectlyBalance` function takes a sorted array of nodes and builds a balanced binary search
+     * tree using either a recursive or iterative approach.
+     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
+     * type of iteration to use when building the balanced binary search tree. It can have two possible
+     * values:
+     * @returns a boolean value.
+     */
+    perfectlyBalance(iterationType = this.iterationType) {
+        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        if (sorted.length < 1)
+            return false;
+        this.clear();
+        if (iterationType === types_1.IterationType.RECURSIVE) {
+            const buildBalanceBST = (l, r) => {
+                if (l > r)
+                    return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.key, midNode.value, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.key, midNode.value, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
+                }
+            }
+            return true;
+        }
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -312,9 +291,9 @@ class TreeMultimap extends avl_tree_1.AVLTree {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
-     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | NODE | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `NODE`, or `undefined`.
+     * @param {K | NODE | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.

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

@@ -40,6 +40,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
     constructor();
     protected _vertexMap: Map<VertexKey, VO>;
     get vertexMap(): Map<VertexKey, VO>;
+    set vertexMap(v: Map<VertexKey, VO>);
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.

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

@@ -47,6 +47,9 @@ class AbstractGraph extends base_1.IterableEntryBase {
     get vertexMap() {
         return this._vertexMap;
     }
+    set vertexMap(v) {
+        this._vertexMap = v;
+    }
     /**
      * Time Complexity: O(1) - Constant time for Map lookup.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.

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

@@ -41,8 +41,10 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
     constructor();
     protected _outEdgeMap: Map<VO, EO[]>;
     get outEdgeMap(): Map<VO, EO[]>;
+    set outEdgeMap(v: Map<VO, EO[]>);
     protected _inEdgeMap: Map<VO, EO[]>;
     get inEdgeMap(): Map<VO, EO[]>;
+    set inEdgeMap(v: Map<VO, EO[]>);
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -327,6 +329,18 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge: EO): [VO, VO] | undefined;
+    /**
+     * The isEmpty function checks if the graph is empty.
+     *
+     * @return A boolean value
+     */
+    isEmpty(): boolean;
+    /**
+     * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
+     *
+     * @return A new instance of the directedgraph class
+     */
+    clone(): DirectedGraph<V, E, VO, EO>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -47,9 +47,15 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
     get outEdgeMap() {
         return this._outEdgeMap;
     }
+    set outEdgeMap(v) {
+        this._outEdgeMap = v;
+    }
     get inEdgeMap() {
         return this._inEdgeMap;
     }
+    set inEdgeMap(v) {
+        this._inEdgeMap = v;
+    }
     /**
      * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
      * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
@@ -527,6 +533,26 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
             return undefined;
         }
     }
+    /**
+     * The isEmpty function checks if the graph is empty.
+     *
+     * @return A boolean value
+     */
+    isEmpty() {
+        return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
+    }
+    /**
+     * The clone function creates a new DirectedGraph object with the same vertices and edges as the original.
+     *
+     * @return A new instance of the directedgraph class
+     */
+    clone() {
+        const cloned = new DirectedGraph();
+        cloned.vertexMap = new Map(this.vertexMap);
+        cloned.inEdgeMap = new Map(this.inEdgeMap);
+        cloned.outEdgeMap = new Map(this.outEdgeMap);
+        return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -70,4 +70,12 @@ export declare class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVer
      * @returns a new instance of the `MapEdge` class, cast as type `EO`.
      */
     createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO;
+    /**
+     * The override function is used to override the default behavior of a function.
+     * In this case, we are overriding the clone() function from Graph&lt;V, E&gt;.
+     * The clone() function returns a new graph that is an exact copy of the original graph.
+     *
+     * @return A mapgraph&lt;v, e, vo, eo&gt;
+     */
+    clone(): MapGraph<V, E, VO, EO>;
 }

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

@@ -89,5 +89,19 @@ class MapGraph extends directed_graph_1.DirectedGraph {
     createEdge(src, dest, weight, value) {
         return new MapEdge(src, dest, weight, value);
     }
+    /**
+     * The override function is used to override the default behavior of a function.
+     * In this case, we are overriding the clone() function from Graph<V, E>.
+     * The clone() function returns a new graph that is an exact copy of the original graph.
+     *
+     * @return A mapgraph<v, e, vo, eo>
+     */
+    clone() {
+        const cloned = new MapGraph(this.originCoord, this.bottomRight);
+        cloned.vertexMap = new Map(this.vertexMap);
+        cloned.inEdgeMap = new Map(this.inEdgeMap);
+        cloned.outEdgeMap = new Map(this.outEdgeMap);
+        return cloned;
+    }
 }
 exports.MapGraph = MapGraph;

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

@@ -39,6 +39,7 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
     constructor();
     protected _edgeMap: Map<VO, EO[]>;
     get edgeMap(): Map<VO, EO[]>;
+    set edgeMap(v: 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
@@ -193,6 +194,21 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * graph. If the edge does not exist, it returns `undefined`.
      */
     getEndsOfEdge(edge: EO): [VO, VO] | undefined;
+    /**
+     * The isEmpty function checks if the graph is empty.
+     * @return True if the graph is empty and false otherwise
+     */
+    isEmpty(): boolean;
+    /**
+     * The clone function creates a new UndirectedGraph object and copies the
+     * vertexMap and edgeMap from this graph to the new one. This is done by
+     * assigning each of these properties to their respective counterparts in the
+     * cloned graph. The clone function returns a reference to this newly created,
+     * cloned UndirectedGraph object.
+     *
+     * @return A new instance of the undirectedgraph class
+     */
+    clone(): UndirectedGraph<V, E, VO, EO>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -44,6 +44,9 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
     get edgeMap() {
         return this._edgeMap;
     }
+    set edgeMap(v) {
+        this._edgeMap = v;
+    }
     /**
      * 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
@@ -325,6 +328,28 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
             return undefined;
         }
     }
+    /**
+     * The isEmpty function checks if the graph is empty.
+     * @return True if the graph is empty and false otherwise
+     */
+    isEmpty() {
+        return this.vertexMap.size === 0 && this.edgeMap.size === 0;
+    }
+    /**
+     * The clone function creates a new UndirectedGraph object and copies the
+     * vertexMap and edgeMap from this graph to the new one. This is done by
+     * assigning each of these properties to their respective counterparts in the
+     * cloned graph. The clone function returns a reference to this newly created,
+     * cloned UndirectedGraph object.
+     *
+     * @return A new instance of the undirectedgraph class
+     */
+    clone() {
+        const cloned = new UndirectedGraph();
+        cloned.vertexMap = new Map(this.vertexMap);
+        cloned.edgeMap = new Map(this.edgeMap);
+        return cloned;
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)