doubly-linked-list-typed 1.54.3 → 2.0.1

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

@@ -339,7 +339,7 @@ export abstract class AbstractGraph<
 
     if (isWeight) {
       const allPaths = this.getAllPathsBetween(v1, v2);
-      let min = Infinity;
+      let min = Number.MAX_SAFE_INTEGER;
       for (const path of allPaths) {
         min = Math.min(this.getPathSumWeight(path), min);
       }
@@ -356,8 +356,8 @@ export abstract class AbstractGraph<
       const queue = new Queue<VO>([vertex1]);
       visited.set(vertex1, true);
       let cost = 0;
-      while (queue.size > 0) {
-        for (let i = 0; i < queue.size; i++) {
+      while (queue.length > 0) {
+        for (let i = 0; i < queue.length; i++) {
           const cur = queue.shift();
           if (cur === vertex2) {
             return cost;
@@ -404,7 +404,7 @@ export abstract class AbstractGraph<
     if (isWeight) {
       if (isDFS) {
         const allPaths = this.getAllPathsBetween(v1, v2, 10000);
-        let min = Infinity;
+        let min = Number.MAX_SAFE_INTEGER;
         let minIndex = -1;
         let index = 0;
         for (const path of allPaths) {
@@ -475,7 +475,7 @@ export abstract class AbstractGraph<
     getMinDist: boolean = false,
     genPaths: boolean = false
   ): DijkstraResult<VO> {
-    let minDist = Infinity;
+    let minDist = Number.MAX_SAFE_INTEGER;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
@@ -494,13 +494,13 @@ export abstract class AbstractGraph<
 
     for (const vertex of vertexMap) {
       const vertexOrKey = vertex[1];
-      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
     }
     distMap.set(srcVertex, 0);
     preMap.set(srcVertex, undefined);
 
     const getMinOfNoSeen = () => {
-      let min = Infinity;
+      let min = Number.MAX_SAFE_INTEGER;
       let minV: VO | undefined = undefined;
       for (const [key, value] of distMap) {
         if (!seen.has(key)) {
@@ -537,7 +537,7 @@ export abstract class AbstractGraph<
         seen.add(cur);
         if (destVertex && destVertex === cur) {
           if (getMinDist) {
-            minDist = distMap.get(destVertex) || Infinity;
+            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
           }
           if (genPaths) {
             getPaths(destVertex);
@@ -605,7 +605,7 @@ export abstract class AbstractGraph<
     getMinDist: boolean = false,
     genPaths: boolean = false
   ): DijkstraResult<VO> {
-    let minDist = Infinity;
+    let minDist = Number.MAX_SAFE_INTEGER;
     let minDest: VO | undefined = undefined;
     let minPath: VO[] = [];
     const paths: VO[][] = [];
@@ -621,7 +621,7 @@ export abstract class AbstractGraph<
 
     for (const vertex of vertexMap) {
       const vertexOrKey = vertex[1];
-      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
     }
 
     const heap = new Heap<{ key: number; value: VO }>([], { comparator: (a, b) => a.key - b.key });
@@ -661,7 +661,7 @@ export abstract class AbstractGraph<
           seen.add(cur);
           if (destVertex && destVertex === cur) {
             if (getMinDist) {
-              minDist = distMap.get(destVertex) || Infinity;
+              minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
             }
             if (genPaths) {
               getPaths(destVertex);
@@ -732,7 +732,7 @@ export abstract class AbstractGraph<
     const paths: VO[][] = [];
     const distMap: Map<VO, number> = new Map();
     const preMap: Map<VO, VO> = new Map(); // predecessor
-    let min = Infinity;
+    let min = Number.MAX_SAFE_INTEGER;
     let minPath: VO[] = [];
     // TODO
     let hasNegativeCycle: boolean | undefined;
@@ -745,7 +745,7 @@ export abstract class AbstractGraph<
     const numOfEdges = edgeMap.length;
 
     this._vertexMap.forEach(vertex => {
-      distMap.set(vertex, Infinity);
+      distMap.set(vertex, Number.MAX_SAFE_INTEGER);
     });
 
     distMap.set(srcVertex, 0);
@@ -759,7 +759,7 @@ export abstract class AbstractGraph<
           const sWeight = distMap.get(s);
           const dWeight = distMap.get(d);
           if (sWeight !== undefined && dWeight !== undefined) {
-            if (distMap.get(s) !== Infinity && sWeight + weight < dWeight) {
+            if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
               distMap.set(d, sWeight + weight);
               if (genPath) preMap.set(d, s);
             }
@@ -804,7 +804,7 @@ export abstract class AbstractGraph<
         const weight = edgeMap[j].weight;
         const sWeight = distMap.get(s);
         if (sWeight) {
-          if (sWeight !== Infinity && sWeight + weight < sWeight) hasNegativeCycle = true;
+          if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight) hasNegativeCycle = true;
         }
       }
     }
@@ -860,7 +860,7 @@ export abstract class AbstractGraph<
 
     for (let i = 0; i < n; i++) {
       for (let j = 0; j < n; j++) {
-        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Infinity;
+        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Number.MAX_SAFE_INTEGER;
       }
     }
 

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

@@ -21,6 +21,52 @@ import { isWeakKey, rangeCheck } from '../../utils';
  * 3. Unique Keys: Keys are unique.
  * If you try to insert another entry with the same key, the new one will replace the old entry.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
+ * @example
+ * // should maintain insertion order
+ *     const linkedHashMap = new LinkedHashMap<number, string>();
+ *     linkedHashMap.set(1, 'A');
+ *     linkedHashMap.set(2, 'B');
+ *     linkedHashMap.set(3, 'C');
+ *
+ *     const result = Array.from(linkedHashMap);
+ *     console.log(result); // [
+ *  //      [1, 'A'],
+ *  //      [2, 'B'],
+ *  //      [3, 'C']
+ *  //    ]
+ * @example
+ * // fast lookup of values by key
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(3, 'C');
+ *
+ *     console.log(hashMap.get(1)); // 'A'
+ *     console.log(hashMap.get(2)); // 'B'
+ *     console.log(hashMap.get(3)); // 'C'
+ *     console.log(hashMap.get(99)); // undefined
+ * @example
+ * // remove duplicates when adding multiple entries
+ *     const hashMap = new HashMap<number, string>();
+ *     hashMap.set(1, 'A');
+ *     hashMap.set(2, 'B');
+ *     hashMap.set(1, 'C'); // Update value for key 1
+ *
+ *     console.log(hashMap.size); // 2
+ *     console.log(hashMap.get(1)); // 'C'
+ *     console.log(hashMap.get(2)); // 'B'
+ * @example
+ * // count occurrences of keys
+ *     const data = [1, 2, 1, 3, 2, 1];
+ *
+ *     const countMap = new HashMap<number, number>();
+ *     for (const key of data) {
+ *       countMap.set(key, (countMap.get(key) || 0) + 1);
+ *     }
+ *
+ *     console.log(countMap.get(1)); // 3
+ *     console.log(countMap.get(2)); // 2
+ *     console.log(countMap.get(3)); // 1
  */
 export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
   /**

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

@@ -185,7 +185,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   /**
    * The constructor initializes a heap data structure with optional elements and options.
    * @param elements - The `elements` parameter is an iterable object that contains the initial
@@ -416,17 +416,6 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
     return result;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * Convert the heap to an array.
-   * @returns An array containing the elements of the heap.
-   */
-  toArray(): E[] {
-    return [...this.elements];
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -483,7 +472,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  filter(callback: ElementCallback<E, R, boolean, Heap<E, R>>, thisArg?: any): Heap<E, R> {
+  filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): Heap<E, R> {
     const filteredList = new Heap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -517,7 +506,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
    * @returns a new instance of the `Heap` class with the mapped elements.
    */
   map<EM, RM>(
-    callback: ElementCallback<E, R, EM, Heap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

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

@@ -61,7 +61,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MaxHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MaxHeap<E, R>>, thisArg?: any): MaxHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MaxHeap<E, R> {
     const filteredList = new MaxHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -95,7 +95,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MaxHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MaxHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any

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

@@ -49,7 +49,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns The `filter` method is returning a new `MinHeap` object that contains the elements that pass
    * the filter condition specified by the `callback` function.
    */
-  override filter(callback: ElementCallback<E, R, boolean, MinHeap<E, R>>, thisArg?: any): MinHeap<E, R> {
+  override filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): MinHeap<E, R> {
     const filteredList = new MinHeap<E, R>([], { toElementFn: this.toElementFn, comparator: this.comparator });
     let index = 0;
     for (const current of this) {
@@ -83,7 +83,7 @@ export class MinHeap<E = any, R = any> extends Heap<E, R> {
    * @returns a new instance of the `MinHeap` class with the mapped elements.
    */
   override map<EM, RM>(
-    callback: ElementCallback<E, R, EM, MinHeap<E, R>>,
+    callback: ElementCallback<E, R, EM>,
     comparator: Comparator<EM>,
     toElementFn?: (rawElement: RM) => EM,
     thisArg?: any