data-structure-typed 1.48.3 → 1.48.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.48.3",
+  "version": "1.48.4",
   "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack.",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",

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

@@ -164,6 +164,11 @@ export abstract class AbstractGraph<
     }
   }
 
+  isVertexKey(potentialKey: any): potentialKey is VertexKey {
+    const potentialKeyType = typeof potentialKey;
+    return potentialKeyType === "string" || potentialKeyType === "number"
+  }
+
   /**
    * Time Complexity: O(1) - Constant time for Map operations.
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.

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

@@ -178,38 +178,87 @@ export class DirectedGraph<
   }
 
   /**
-   * Time Complexity: O(|E|) where |E| is the number of edges
+   * Time Complexity: O(E) where E is the number of edges
    * Space Complexity: O(1)
    */
 
+
   /**
-   * Time Complexity: O(|E|) where |E| is the number of edges
+   * Time Complexity: O(E) where E is the number of edges
    * Space Complexity: O(1)
    *
-   * The function removes an edge from a graph and returns the removed edge, or undefined if the edge was not found.
-   * @param {EO} edge - The `edge` parameter is an object that represents an edge in a graph. It has two properties: `src`
-   * and `dest`, which represent the source and destination vertices of the edge, respectively.
-   * @returns The method `deleteEdge` returns the removed edge (`EO`) if it exists, or `undefined` if the edge does not exist.
-   */
-  deleteEdge(edge: EO): EO | undefined {
+   * The `deleteEdge` function removes an edge from a graph and returns the removed edge.
+   * @param {EO | VertexKey} edgeOrSrcVertexKey - The `edge` parameter can be either an `EO` object (edge object) or
+   * a `VertexKey` (key of a vertex).
+   * @param {VertexKey} [destVertexKey] - The `destVertexKey` parameter is an optional parameter that
+   * represents the key of the destination vertex of the edge. It is used to specify the destination
+   * vertex when the `edge` parameter is a vertex key. If `destVertexKey` is not provided, the function
+   * assumes that the `edge`
+   * @returns the removed edge (EO) or undefined if no edge was removed.
+   */
+  deleteEdge(edgeOrSrcVertexKey: EO | VertexKey, destVertexKey?: VertexKey): EO | undefined {
     let removed: EO | undefined = undefined;
-    const src = this._getVertex(edge.src);
-    const dest = this._getVertex(edge.dest);
+    let src: VO | undefined, dest: VO | undefined;
+    if (this.isVertexKey(edgeOrSrcVertexKey)) {
+      if (this.isVertexKey(destVertexKey)) {
+        src = this._getVertex(edgeOrSrcVertexKey);
+        dest = this._getVertex(destVertexKey);
+      } else {
+        return;
+      }
+    } else {
+      src = this._getVertex(edgeOrSrcVertexKey.src);
+      dest = this._getVertex(edgeOrSrcVertexKey.dest);
+    }
+
     if (src && dest) {
       const srcOutEdges = this._outEdgeMap.get(src);
       if (srcOutEdges && srcOutEdges.length > 0) {
-        arrayRemove(srcOutEdges, (edge: EO) => edge.src === src.key);
+        arrayRemove(srcOutEdges, (edge: EO) => edge.src === src!.key && edge.dest === dest?.key);
       }
 
       const destInEdges = this._inEdgeMap.get(dest);
       if (destInEdges && destInEdges.length > 0) {
-        removed = arrayRemove(destInEdges, (edge: EO) => edge.dest === dest.key)[0];
+        removed = arrayRemove(destInEdges, (edge: EO) => edge.src === src!.key && edge.dest === dest!.key)[0];
       }
     }
 
     return removed;
   }
 
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   */
+
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns The method is returning a boolean value.
+   */
+  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+    let vertexKey: VertexKey;
+    let vertex: VO | undefined;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertex = this.getVertex(vertexOrKey);
+      vertexKey = vertexOrKey;
+    } else {
+      vertex = vertexOrKey;
+      vertexKey = this._getVertexKey(vertexOrKey)
+    }
+
+    if (vertex) {
+      this._outEdgeMap.delete(vertex)
+      this._inEdgeMap.delete(vertex)
+    }
+
+    return this._vertices.delete(vertexKey);
+  }
+
   /**
    * Time Complexity: O(|E|) where |E| is the number of edges
    * Space Complexity: O(1)

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

@@ -158,20 +158,88 @@ export class UndirectedGraph<
   }
 
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
    * Space Complexity: O(1)
    */
 
+
   /**
-   * Time Complexity: O(|E|), where |E| is the number of edges incident to the given vertex.
+   * Time Complexity: O(E), where E is the number of edges incident to the given vertex.
    * Space Complexity: O(1)
    *
-   * The deleteEdge function removes an edge between two vertices in a graph.
-   * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
-   * @returns The method is returning either the removed edge (of type EO) or undefined if the edge was not found.
+   * The function `deleteEdge` deletes an edge between two vertices in a graph.
+   * @param {EO | VertexKey} edgeOrOneSideVertexKey - The parameter `edgeOrOneSideVertexKey` can be
+   * either an edge object or a vertex key.
+   * @param {VertexKey} [otherSideVertexKey] - The parameter `otherSideVertexKey` is an optional
+   * parameter that represents the key of the vertex on the other side of the edge. It is used when the
+   * `edgeOrOneSideVertexKey` parameter is a vertex key, and it specifies the key of the vertex on the
+   * other side of the
+   * @returns The `deleteEdge` function returns either the deleted edge object (EO) or `undefined`.
+   */
+  deleteEdge(edgeOrOneSideVertexKey: EO | VertexKey, otherSideVertexKey?: VertexKey): EO | undefined {
+    let oneSide: VO | undefined, otherSide: VO | undefined;
+    if (this.isVertexKey(edgeOrOneSideVertexKey)) {
+      if (this.isVertexKey(otherSideVertexKey)) {
+        oneSide = this._getVertex(edgeOrOneSideVertexKey);
+        otherSide = this._getVertex(otherSideVertexKey);
+      } else {
+        return;
+      }
+    } else {
+      oneSide = this._getVertex(edgeOrOneSideVertexKey.vertices[0]);
+      otherSide = this._getVertex(edgeOrOneSideVertexKey.vertices[1]);
+    }
+
+    if (oneSide && otherSide) {
+      return this.deleteEdgeBetween(oneSide, otherSide);
+
+    } else {
+      return;
+    }
+  }
+
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
    */
-  deleteEdge(edge: EO): EO | undefined {
-    return this.deleteEdgeBetween(edge.vertices[0], edge.vertices[1]);
+
+  /**
+   * Time Complexity: O(1) - Constant time for Map operations.
+   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
+   *
+   * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
+   * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
+   * (`VertexKey`).
+   * @returns The method is returning a boolean value.
+   */
+  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+    let vertexKey: VertexKey;
+    let vertex: VO | undefined;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertex = this.getVertex(vertexOrKey);
+      vertexKey = vertexOrKey;
+    } else {
+      vertex = vertexOrKey;
+      vertexKey = this._getVertexKey(vertexOrKey)
+    }
+
+    const neighbors = this.getNeighbors(vertexOrKey)
+
+    if (vertex) {
+      neighbors.forEach(neighbor => {
+        const neighborEdges = this._edges.get(neighbor);
+        if (neighborEdges) {
+          const restEdges = neighborEdges.filter(edge => {
+            return !edge.vertices.includes(vertexKey);
+          });
+          this._edges.set(neighbor, restEdges);
+        }
+      })
+      this._edges.delete(vertex);
+
+    }
+
+    return this._vertices.delete(vertexKey);
   }
 
   /**

package/test/integration/bst.test.ts

@@ -183,7 +183,7 @@ describe('Individual package BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<{ key: number; keyA: number }>();
+    const objBST = new BST<number,{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -634,5 +634,42 @@ describe('DirectedGraph iterative Methods', () => {
     const concatenated = graph.reduce((acc, value, key) => acc + key, '');
     expect(concatenated).toBe(vertices.join(''));
   });
+
+  test('Removing an edge of a DirectedGraph should not delete additional edges', () => {
+    const dg = new DirectedGraph();
+    dg.addVertex('hello')
+    dg.addVertex('hi')
+    dg.addVertex('hey')
+    dg.addEdge('hello', 'hi')
+    dg.addEdge('hello', 'hey')
+    expect(dg.getEdge('hello', 'hi')?.src).toBe('hello')
+    expect(dg.getEdge('hello', 'hi')?.dest).toBe('hi')
+    expect(dg.getEdge('hello', 'hey')?.src).toBe('hello')
+    expect(dg.getEdge('hello', 'hey')?.dest).toBe('hey')
+    dg.deleteEdge('hello', 'hi')
+    expect(dg.getEdge('hello', 'hi')).toBe(undefined)
+    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(DirectedEdge)
+  });
+
+  test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
+    const dg = new DirectedGraph();
+    dg.addVertex('hello')
+    dg.addVertex('world')
+    dg.addVertex('earth')
+
+    dg.addEdge('hello', 'world')
+    dg.addEdge('hello', 'earth')
+    dg.addEdge('world', 'earth')
+
+    expect(dg.getEdge('hello', 'world')?.src).toBe('hello');
+    expect(dg.edgeSet().length).toBe(3)
+    expect(dg.edgeSet()[0].dest).toBe('world')
+
+    dg.deleteVertex('hello')
+    expect(dg.edgeSet().length).toBe(1)
+    expect(dg.edgeSet()?.[0].src).toBe('world')
+
+    expect(dg.getEdge('hello', 'world')).toBe(undefined);
+  })
 });
 

package/test/unit/data-structures/graph/undirected-graph.test.ts

@@ -173,6 +173,43 @@ describe('UndirectedGraph', () => {
     expect(minWeightedPath?.minPath?.[3]?.key).toBe('Intersection_4');
     expect(minWeightedPath?.minPath?.[4]?.key).toBe('Intersection_5');
   });
+
+  test('Removing an edge of a UndirectedGraph should not delete additional edges', () => {
+    const dg = new UndirectedGraph();
+    dg.addVertex('hello')
+    dg.addVertex('hi')
+    dg.addVertex('hey')
+    dg.addEdge('hello', 'hi')
+    dg.addEdge('hello', 'hey')
+    expect(dg.getEdge('hello', 'hi')?.vertices[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hi')?.vertices[1]).toBe('hi')
+    expect(dg.getEdge('hello', 'hey')?.vertices[0]).toBe('hello')
+    expect(dg.getEdge('hello', 'hey')?.vertices[1]).toBe('hey')
+    dg.deleteEdge('hello', 'hi')
+    expect(dg.getEdge('hello', 'hi')).toBe(undefined)
+    expect(dg.getEdge('hello', 'hey')).toBeInstanceOf(UndirectedEdge)
+  });
+
+  test('Removing a vertex from a UndirectedGraph should remove its edges', () => {
+    const dg = new UndirectedGraph();
+    dg.addVertex('hello')
+    dg.addVertex('world')
+    dg.addVertex('earth')
+
+    dg.addEdge('hello', 'world')
+    dg.addEdge('hello', 'earth')
+    dg.addEdge('world', 'earth')
+
+    expect(dg.getEdge('hello', 'world')?.vertices[0]).toBe('hello');
+    expect(dg.edgeSet().length).toBe(3)
+    expect(dg.edgeSet()[0].vertices).toEqual(['hello', 'world'])
+
+    dg.deleteVertex('hello')
+    expect(dg.edgeSet().length).toBe(1)
+    expect(dg.edgeSet()?.[0].vertices[0]).toBe('world')
+
+    expect(dg.getEdge('hello', 'world')).toBe(undefined);
+  })
 });
 
 describe('cycles, strongly connected components, bridges, articular points in UndirectedGraph', () => {