data-structure-typed 1.49.3 → 1.49.5

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

@@ -45,11 +45,14 @@ export class TreeMultimapNode<
 /**
  * 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 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>>>
+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>>
+>
   extends AVLTree<K, V, N, TREE>
   implements IBinaryTree<K, V, N, TREE> {
-
   constructor(elements?: Iterable<BTNExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>) {
     super([], options);
     if (elements) this.addMany(elements);
@@ -60,7 +63,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   // TODO the _count is not accurate after nodes count modified
   get count(): number {
     let sum = 0;
-    this.subTreeTraverse(node => sum += node.count);
+    this.subTreeTraverse(node => (sum += node.count));
     return sum;
   }
 
@@ -80,7 +83,8 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   override createTree(options?: TreeMultimapOptions<K>): TREE {
     return new TreeMultimap<K, V, N, TREE>([], {
       iterationType: this.iterationType,
-      variant: this.variant, ...options
+      variant: this.variant,
+      ...options
     }) as TREE;
   }
 
@@ -101,7 +105,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
    * @returns a boolean value indicating whether the potentialKey is of type number or not.
    */
   override isNotNodeInstance(potentialKey: BTNKeyOrNode<K, N>): potentialKey is K {
-    return !(potentialKey instanceof TreeMultimapNode)
+    return !(potentialKey instanceof TreeMultimapNode);
   }
 
   /**
@@ -357,47 +361,6 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
     return cloned;
   }
 
-  /**
-   * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
-   * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
-   *
-   * The function adds a new node to a binary tree, either as the left child or the right child of a
-   * given parent node.
-   * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
-   * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
-   * `undefined` if there is no node to add.
-   * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
-   * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-   * (`K`).
-   * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
-   * added, or `undefined` if no node was added.
-   */
-  protected override _addTo(newNode: N | undefined, parent: BSTNKeyOrNode<K, N>): N | undefined {
-    parent = this.ensureNode(parent);
-    if (parent) {
-      if (parent.left === undefined) {
-        parent.left = newNode;
-        if (newNode !== undefined) {
-          this._size = this.size + 1;
-          this._count += newNode.count;
-        }
-
-        return parent.left;
-      } else if (parent.right === undefined) {
-        parent.right = newNode;
-        if (newNode !== undefined) {
-          this._size = this.size + 1;
-          this._count += newNode.count;
-        }
-        return parent.right;
-      } else {
-        return;
-      }
-    } else {
-      return;
-    }
-  }
-
   /**
    * 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
@@ -433,7 +396,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   }
 
   protected _replaceNode(oldNode: N, newNode: N): N {
-    newNode.count = oldNode.count + newNode.count
+    newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }
 }

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

@@ -7,7 +7,7 @@
  */
 import type { DijkstraResult, EntryCallback, VertexKey } from '../../types';
 import { uuidV4 } from '../../utils';
-import { IterableEntryBase } from "../base";
+import { IterableEntryBase } from '../base';
 import { IGraph } from '../../interfaces';
 import { Heap } from '../heap';
 import { Queue } from '../queue';
@@ -65,7 +65,9 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> extends IterableEntryBase<VertexKey, V | undefined> implements IGraph<V, E, VO, EO> {
+>
+  extends IterableEntryBase<VertexKey, V | undefined>
+  implements IGraph<V, E, VO, EO> {
   constructor() {
     super();
   }
@@ -165,7 +167,7 @@ export abstract class AbstractGraph<
 
   isVertexKey(potentialKey: any): potentialKey is VertexKey {
     const potentialKeyType = typeof potentialKey;
-    return potentialKeyType === "string" || potentialKeyType === "number"
+    return potentialKeyType === 'string' || potentialKeyType === 'number';
   }
 
   /**
@@ -173,19 +175,7 @@ export abstract class AbstractGraph<
    * 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.
-   */
-  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
-    const vertexKey = this._getVertexKey(vertexOrKey);
-    return this._vertexMap.delete(vertexKey);
-  }
+  abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
 
   /**
    * Time Complexity: O(K), where K is the number of vertexMap to be removed.
@@ -674,7 +664,6 @@ export abstract class AbstractGraph<
     getMinDist: boolean = false,
     genPaths: boolean = false
   ): DijkstraResult<VO> {
-
     let minDist = Infinity;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
@@ -1182,7 +1171,10 @@ export abstract class AbstractGraph<
 
     const dfs = (vertex: VO, currentPath: VertexKey[], visited: Set<VO>) => {
       if (visited.has(vertex)) {
-        if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+        if (
+          ((!isInclude2Cycle && currentPath.length > 2) || (isInclude2Cycle && currentPath.length >= 2)) &&
+          currentPath[0] === vertex.key
+        ) {
           cycles.push([...currentPath]);
         }
         return;
@@ -1207,18 +1199,16 @@ export abstract class AbstractGraph<
     const uniqueCycles = new Map<string, VertexKey[]>();
 
     for (const cycle of cycles) {
-      const sorted = [...cycle].sort().toString()
+      const sorted = [...cycle].sort().toString();
 
-      if (uniqueCycles.has(sorted)) continue
+      if (uniqueCycles.has(sorted)) continue;
       else {
-        uniqueCycles.set(sorted, cycle)
+        uniqueCycles.set(sorted, cycle);
       }
     }
 
     // Convert the unique cycles back to an array
-    return [...uniqueCycles].map(cycleString =>
-      cycleString[1]
-    );
+    return [...uniqueCycles].map(cycleString => cycleString[1]);
   }
 
   /**

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

@@ -182,7 +182,6 @@ export class DirectedGraph<
    * Space Complexity: O(1)
    */
 
-
   /**
    * Time Complexity: O(E) where E is the number of edgeMap
    * Space Complexity: O(1)
@@ -240,7 +239,7 @@ export class DirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {
@@ -248,12 +247,16 @@ export class DirectedGraph<
       vertexKey = vertexOrKey;
     } else {
       vertex = vertexOrKey;
-      vertexKey = this._getVertexKey(vertexOrKey)
+      vertexKey = this._getVertexKey(vertexOrKey);
     }
 
     if (vertex) {
-      this._outEdgeMap.delete(vertex)
-      this._inEdgeMap.delete(vertex)
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        this._inEdgeMap.delete(neighbor);
+      }
+      this._outEdgeMap.delete(vertex);
+      this._inEdgeMap.delete(vertex);
     }
 
     return this._vertexMap.delete(vertexKey);
@@ -596,7 +599,6 @@ export class DirectedGraph<
     }
   }
 
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

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

@@ -84,7 +84,12 @@ export class MapGraph<
    * @param {number} long - The `long` parameter represents the longitude coordinate of the vertex.
    * @returns The method is returning a new instance of the `MapVertex` class, casted as type `VO`.
    */
-  override createVertex(key: VertexKey, value?: V, lat: number = this.originCoord[0], long: number = this.originCoord[1]): VO {
+  override createVertex(
+    key: VertexKey,
+    value?: V,
+    lat: number = this.originCoord[0],
+    long: number = this.originCoord[1]
+  ): VO {
     return new MapVertex(key, value, lat, long) as VO;
   }
 

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

@@ -162,7 +162,6 @@ export class UndirectedGraph<
    * Space Complexity: O(1)
    */
 
-
   /**
    * Time Complexity: O(E), where E is the number of edgeMap incident to the given vertex.
    * Space Complexity: O(1)
@@ -192,7 +191,6 @@ export class UndirectedGraph<
 
     if (oneSide && otherSide) {
       return this.deleteEdgeBetween(oneSide, otherSide);
-
     } else {
       return;
     }
@@ -212,7 +210,7 @@ export class UndirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {
@@ -220,10 +218,10 @@ export class UndirectedGraph<
       vertexKey = vertexOrKey;
     } else {
       vertex = vertexOrKey;
-      vertexKey = this._getVertexKey(vertexOrKey)
+      vertexKey = this._getVertexKey(vertexOrKey);
     }
 
-    const neighbors = this.getNeighbors(vertexOrKey)
+    const neighbors = this.getNeighbors(vertexOrKey);
 
     if (vertex) {
       neighbors.forEach(neighbor => {
@@ -234,9 +232,8 @@ export class UndirectedGraph<
           });
           this._edgeMap.set(neighbor, restEdges);
         }
-      })
+      });
       this._edgeMap.delete(vertex);
-
     }
 
     return this._vertexMap.delete(vertexKey);

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

@@ -27,9 +27,12 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
    * @param [options] - The `options` parameter is an optional object that can contain additional
    * configuration options for the constructor. In this case, it has one property:
    */
-  constructor(elements: Iterable<[K, V]> = [], options?: {
-    hashFn: (key: K) => string
-  }) {
+  constructor(
+    elements: Iterable<[K, V]> = [],
+    options?: {
+      hashFn: (key: K) => string;
+    }
+  ) {
     super();
     if (options) {
       const { hashFn } = options;
@@ -73,7 +76,6 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
         this._size++;
       }
       this._objMap.set(key, value);
-
     } else {
       const strKey = this._getNoObjKey(key);
       if (this._store[strKey] === undefined) {
@@ -137,7 +139,7 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   delete(key: K): boolean {
     if (this._isObjKey(key)) {
       if (this._objMap.has(key)) {
-        this._size--
+        this._size--;
       }
 
       return this._objMap.delete(key);
@@ -235,19 +237,19 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 
   protected _hashFn: (key: K) => string = (key: K) => String(key);
 
-  protected _isObjKey(key: any): key is (object | ((...args: any[]) => any)) {
+  protected _isObjKey(key: any): key is object | ((...args: any[]) => any) {
     const keyType = typeof key;
-    return (keyType === 'object' || keyType === 'function') && key !== null
+    return (keyType === 'object' || keyType === 'function') && key !== null;
   }
 
   protected _getNoObjKey(key: K): string {
     const keyType = typeof key;
 
     let strKey: string;
-    if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+    if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
       strKey = this._hashFn(key);
     } else {
-      if (keyType === "number") {
+      if (keyType === 'number') {
         // TODO numeric key should has its own hash
         strKey = <string>key;
       } else {
@@ -264,7 +266,6 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
  * 3. Time Complexity: Similar to HashMap, LinkedHashMap offers constant-time performance for get and put operations in most cases.
  */
 export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
-
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
   protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
   protected _head: HashMapLinkedNode<K, V | undefined>;
@@ -273,12 +274,13 @@ export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   protected _hashFn: (key: K) => string;
   protected _objHashFn: (key: K) => object;
 
-
-  constructor(elements?: Iterable<[K, V]>, options: HashMapOptions<K> = {
-
-    hashFn: (key: K) => String(key),
-    objHashFn: (key: K) => (<object>key)
-  }) {
+  constructor(
+    elements?: Iterable<[K, V]>,
+    options: HashMapOptions<K> = {
+      hashFn: (key: K) => String(key),
+      objHashFn: (key: K) => <object>key
+    }
+  ) {
     super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;

package/src/data-structures/heap/heap.ts

@@ -31,13 +31,13 @@ export class Heap<E = any> extends IterableElementBase<E> {
       } else {
         return a - b;
       }
-    }
+    };
     if (options) {
-      this.options = options
+      this.options = options;
     } else {
       this.options = {
         comparator: defaultComparator
-      }
+      };
     }
 
     if (elements) {
@@ -225,7 +225,8 @@ export class Heap<E = any> extends IterableElementBase<E> {
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
     const _dfs = (index: number) => {
-      const left = 2 * index + 1, right = left + 1;
+      const left = 2 * index + 1,
+        right = left + 1;
       if (index < this.size) {
         if (order === 'in') {
           _dfs(left);
@@ -380,7 +381,6 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * original Heap.
    */
   map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T> {
-
     const mappedHeap: Heap<T> = new Heap<T>([], { comparator: comparator });
     let index = 0;
     for (const el of this) {
@@ -432,13 +432,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
   protected _sinkDown(index: number, halfLength: number): boolean {
     const element = this.elements[index];
     while (index < halfLength) {
-      let left = index << 1 | 1;
+      let left = (index << 1) | 1;
       const right = left + 1;
       let minItem = this.elements[left];
-      if (
-        right < this.elements.length &&
-        this.options.comparator(minItem, this.elements[right]) > 0
-      ) {
+      if (right < this.elements.length && this.options.comparator(minItem, this.elements[right]) > 0) {
         left = right;
         minItem = this.elements[right];
       }

package/src/data-structures/heap/max-heap.ts

@@ -29,7 +29,8 @@ export class MaxHeap<E = any> extends Heap<E> {
           return b - a;
         }
       }
-    }) {
+    }
+  ) {
     super(elements, options);
   }
 }

package/src/data-structures/heap/min-heap.ts

@@ -29,7 +29,8 @@ export class MinHeap<E = any> extends Heap<E> {
           return a - b;
         }
       }
-    }) {
+    }
+  ) {
     super(elements, options);
   }
 }

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from "../../types";
-import { IterableElementBase } from "../base";
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 
 export class SinglyLinkedListNode<E = any> {
   value: E;
@@ -33,8 +33,7 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     this._tail = undefined;
     this._size = 0;
     if (elements) {
-      for (const el of elements)
-        this.push(el);
+      for (const el of elements) this.push(el);
     }
   }
 
@@ -716,7 +715,6 @@ export class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     return filteredList;
   }
 
-
   /**
    * Time Complexity: O(n), where n is the number of elements in the linked list.
    * Space Complexity: O(n)

package/src/data-structures/matrix/index.ts

@@ -1,4 +1,2 @@
 export * from './matrix';
-export * from './vector2d';
-export * from './matrix2d';
 export * from './navigator';