min-heap-typed 1.50.0 → 1.50.2

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

@@ -21,8 +21,8 @@ import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultimapNode<
   K = any,
   V = any,
-  N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>
-> extends AVLTreeNode<K, V, N> {
+  NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>
+> extends AVLTreeNode<K, V, NODE> {
   count: number;
 
   /**
@@ -47,12 +47,12 @@ export class TreeMultimapNode<
 export 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>>
+  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, N, TREE>
-  implements IBinaryTree<K, V, N, TREE> {
-  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>> = [], options?: TreeMultimapOptions<K>) {
+  extends AVLTree<K, V, NODE, TREE>
+  implements IBinaryTree<K, V, NODE, TREE> {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: TreeMultimapOptions<K>) {
     super([], options);
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
@@ -70,17 +70,17 @@ export class TreeMultimap<
    * 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).
    */
-  override createNode(key: K, value?: V, count?: number): N {
-    return new TreeMultimapNode(key, value, count) as N;
+  override createNode(key: K, value?: V, count?: number): NODE {
+    return new TreeMultimapNode(key, value, count) as NODE;
   }
 
   override createTree(options?: TreeMultimapOptions<K>): TREE {
-    return new TreeMultimap<K, V, N, TREE>([], {
+    return new TreeMultimap<K, V, NODE, TREE>([], {
       iterationType: this.iterationType,
       variant: this.variant,
       ...options
@@ -88,18 +88,22 @@ export class TreeMultimap<
   }
 
   /**
-   * 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`.
    */
-  override exemplarToNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count = 1): N | undefined {
-    let node: N | undefined;
+  override keyValueOrEntryToNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    value?: V,
+    count = 1
+  ): NODE | undefined {
+    let node: NODE | undefined;
     if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
       return;
     } else if (this.isNode(keyOrNodeOrEntry)) {
@@ -121,18 +125,17 @@ export class TreeMultimap<
 
   /**
    * 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.
    */
-  override isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>): keyOrNodeOrEntry is N {
+  override isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE {
     return keyOrNodeOrEntry instanceof TreeMultimapNode;
   }
 
   /**
    * 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.
    */
 
   /**
@@ -151,8 +154,8 @@ export class TreeMultimap<
    * @returns The method is returning either the newly inserted node or `undefined` if the insertion
    * was not successful.
    */
-  override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count = 1): boolean {
-    const newNode = this.exemplarToNode(keyOrNodeOrEntry, value, count);
+  override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count = 1): boolean {
+    const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value, count);
     if (newNode === undefined) return false;
 
     const orgNodeCount = newNode?.count || 0;
@@ -164,88 +167,12 @@ export class TreeMultimap<
   }
 
   /**
-   * 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`.
-   */
-  override addMany(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, N>>): boolean[] {
-    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.
-   */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
-      n = sorted.length;
-    if (sorted.length < 1) return false;
-
-    this.clear();
-
-    if (iterationType === IterationType.RECURSIVE) {
-      const buildBalanceBST = (l: number, r: number) => {
-        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: [[number, number]] = [[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
@@ -261,22 +188,22 @@ export class TreeMultimap<
    * 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>`.
    */
-  override delete<C extends BTNCallback<N>>(
+  override delete<C extends BTNCallback<NODE>>(
     identifier: ReturnType<C>,
     callback: C = this._defaultOneParamCallback as C,
     ignoreCount = false
-  ): BinaryTreeDeleteResult<N>[] {
-    const deletedResult: BinaryTreeDeleteResult<N>[] = [];
+  ): BinaryTreeDeleteResult<NODE>[] {
+    const deletedResult: BinaryTreeDeleteResult<NODE>[] = [];
     if (!this.root) return deletedResult;
 
-    const curr: N | undefined = this.getNode(identifier, callback) ?? undefined;
+    const curr: NODE | undefined = this.getNode(identifier, callback) ?? undefined;
     if (!curr) return deletedResult;
 
-    const parent: N | undefined = curr?.parent ? curr.parent : undefined;
-    let needBalanced: N | undefined = undefined,
-      orgCurrent: N | undefined = curr;
+    const parent: NODE | undefined = curr?.parent ? curr.parent : undefined;
+    let needBalanced: NODE | undefined = undefined,
+      orgCurrent: NODE | undefined = curr;
 
     if (curr.count > 1 && !ignoreCount) {
       curr.count--;
@@ -339,6 +266,60 @@ export class TreeMultimap<
     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.
+   */
+  override perfectlyBalance(iterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'in'),
+      n = sorted.length;
+    if (sorted.length < 1) return false;
+
+    this.clear();
+
+    if (iterationType === IterationType.RECURSIVE) {
+      const buildBalanceBST = (l: number, r: number) => {
+        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: [[number, number]] = [[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)
@@ -359,14 +340,17 @@ export class TreeMultimap<
 
   /**
    * 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 override _swapProperties(srcNode: BSTNKeyOrNode<K, N>, destNode: BSTNKeyOrNode<K, N>): N | undefined {
+  protected override _swapProperties(
+    srcNode: BSTNKeyOrNode<K, NODE>,
+    destNode: BSTNKeyOrNode<K, NODE>
+  ): NODE | undefined {
     srcNode = this.ensureNode(srcNode);
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
@@ -391,7 +375,7 @@ export class TreeMultimap<
     return undefined;
   }
 
-  protected _replaceNode(oldNode: N, newNode: N): N {
+  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }

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

@@ -78,6 +78,10 @@ export abstract class AbstractGraph<
     return this._vertexMap;
   }
 
+  set vertexMap(v: Map<VertexKey, VO>) {
+    this._vertexMap = 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.

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

@@ -66,12 +66,20 @@ export class DirectedGraph<
     return this._outEdgeMap;
   }
 
+  set outEdgeMap(v: Map<VO, EO[]>) {
+    this._outEdgeMap = v;
+  }
+
   protected _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get inEdgeMap(): Map<VO, EO[]> {
     return this._inEdgeMap;
   }
 
+  set inEdgeMap(v: Map<VO, EO[]>) {
+    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.
@@ -599,6 +607,28 @@ export class DirectedGraph<
     }
   }
 
+  /**
+   * The isEmpty function checks if the graph is empty.
+   *
+   * @return A boolean value
+   */
+  isEmpty(): boolean {
+    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(): DirectedGraph<V, E, VO, EO> {
+    const cloned = new DirectedGraph<V, E, VO, EO>();
+    cloned.vertexMap = new Map<VertexKey, VO>(this.vertexMap);
+    cloned.inEdgeMap = new Map<VO, EO[]>(this.inEdgeMap);
+    cloned.outEdgeMap = new Map<VO, EO[]>(this.outEdgeMap);
+    return cloned;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

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

@@ -108,4 +108,19 @@ export class MapGraph<
   override createEdge(src: VertexKey, dest: VertexKey, weight?: number, value?: E): EO {
     return new MapEdge(src, dest, weight, value) as 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;
+   */
+  override clone(): MapGraph<V, E, VO, EO> {
+    const cloned = new MapGraph<V, E, VO, EO>(this.originCoord, this.bottomRight);
+    cloned.vertexMap = new Map<VertexKey, VO>(this.vertexMap);
+    cloned.inEdgeMap = new Map<VO, EO[]>(this.inEdgeMap);
+    cloned.outEdgeMap = new Map<VO, EO[]>(this.outEdgeMap);
+    return cloned;
+  }
 }

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

@@ -64,6 +64,10 @@ export class UndirectedGraph<
     return this._edgeMap;
   }
 
+  set edgeMap(v: Map<VO, EO[]>) {
+    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
@@ -365,6 +369,30 @@ export class UndirectedGraph<
     }
   }
 
+  /**
+   * The isEmpty function checks if the graph is empty.
+   * @return True if the graph is empty and false otherwise
+   */
+  isEmpty(): boolean {
+    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(): UndirectedGraph<V, E, VO, EO> {
+    const cloned = new UndirectedGraph<V, E, VO, EO>();
+    cloned.vertexMap = new Map<VertexKey, VO>(this.vertexMap);
+    cloned.edgeMap = new Map<VO, EO[]>(this.edgeMap);
+    return cloned;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)