heap-typed 1.52.3 → 1.52.5

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

@@ -23,6 +23,7 @@ import { BTNEntry } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
+import { isComparable } from '../../utils';
 
 export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<
   K,
@@ -195,7 +196,7 @@ export class BST<
    */
   override ensureNode(
     keyOrNodeOrEntryOrRawElement: R | BTNKeyOrNodeOrEntry<K, V, NODE>,
-    iterationType: IterationType = 'ITERATIVE'
+    iterationType: IterationType = this.iterationType
   ): OptBSTN<NODE> {
     return super.ensureNode(keyOrNodeOrEntryOrRawElement, iterationType) ?? undefined;
   }
@@ -213,6 +214,10 @@ export class BST<
     return keyOrNodeOrEntryOrRawElement instanceof BSTNode;
   }
 
+  override isKey(key: any): key is K {
+    return isComparable(key, this.comparator !== this._DEFAULT_COMPARATOR);
+  }
+
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -259,11 +264,6 @@ export class BST<
     return false;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(log n)
-   */
-
   /**
    * Time Complexity: O(k log n)
    * Space Complexity: O(k + log n)
@@ -413,6 +413,8 @@ export class BST<
     beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): NODE[] {
+    if (identifier === undefined) return [];
+    if (identifier === null) return [];
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
     callback = this._ensureCallback(identifier, callback);
@@ -469,11 +471,6 @@ export class BST<
     return ans;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -504,11 +501,6 @@ export class BST<
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
-  /**
-   * Time Complexity: O(k log n)
-   * Space Complexity: O(k + log n)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -522,15 +514,10 @@ export class BST<
    * It has a default value of `'ITERATIVE'`.
    * @returns The method is returning a NODE object or undefined.
    */
-  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): OptBSTN<NODE> {
+  override getNodeByKey(key: K, iterationType: IterationType = this.iterationType): OptBSTN<NODE> {
     return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(k + log n)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -555,16 +542,11 @@ export class BST<
     callback: C = this._DEFAULT_CALLBACK as C,
     pattern: DFSOrderPattern = 'IN',
     beginRoot: R | BTNKeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType: IterationType = 'ITERATIVE'
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
-    return super.dfs(callback, pattern, beginRoot, iterationType, false);
+    return super.dfs(callback, pattern, beginRoot, iterationType);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -590,11 +572,6 @@ export class BST<
     return super.bfs(callback, beginRoot, iterationType, false);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -621,11 +598,6 @@ export class BST<
     return super.listLevels(callback, beginRoot, iterationType, false);
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -687,11 +659,6 @@ export class BST<
     }
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -741,11 +708,6 @@ export class BST<
     }
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(log n)
@@ -815,11 +777,6 @@ export class BST<
 
   protected _comparator: Comparator<K> = this._DEFAULT_COMPARATOR;
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(log n)
-   */
-
   /**
    * The function returns the value of the _comparator property.
    * @returns The `_comparator` property is being returned.

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

@@ -126,11 +126,6 @@ export class RedBlackTree<
     }) as TREE;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -169,7 +164,7 @@ export class RedBlackTree<
   //
   //   if (this.toEntryFn) {
   //     const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
-  //     if (key) return this.createNode(key, entryValue ?? value, 'RED');
+  //     if (this.isKey(key)) return this.createNode(key, entryValue ?? value, 'RED');
   //   }
   //
   //   if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
@@ -183,11 +178,6 @@ export class RedBlackTree<
   //   return ;
   // }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -200,11 +190,6 @@ export class RedBlackTree<
     this._root = this.NIL;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -238,11 +223,6 @@ export class RedBlackTree<
     } else return insertStatus === 'UPDATED';
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -282,7 +262,7 @@ export class RedBlackTree<
       replacementNode = nodeToDelete.left;
       this._transplant(nodeToDelete, nodeToDelete.left);
     } else {
-      const successor = this.getLeftMost(nodeToDelete.right);
+      const successor = this.getLeftMost(node => node, nodeToDelete.right);
       if (successor) {
         originalColor = successor.color;
         replacementNode = successor.right;
@@ -319,11 +299,6 @@ export class RedBlackTree<
     return results;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -339,11 +314,6 @@ export class RedBlackTree<
     this._root = v;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -362,11 +332,6 @@ export class RedBlackTree<
     return super._replaceNode(oldNode, newNode);
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -414,11 +379,6 @@ export class RedBlackTree<
     return 'CREATED';
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -442,11 +402,6 @@ export class RedBlackTree<
     }
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -513,11 +468,6 @@ export class RedBlackTree<
     if (this.isRealNode(this._root)) this._root.color = 'BLACK';
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -601,11 +551,6 @@ export class RedBlackTree<
     }
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -641,11 +586,6 @@ export class RedBlackTree<
     x.parent = y;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -100,11 +100,6 @@ export class TreeMultiMap<
     return this._count;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -172,15 +167,15 @@ export class TreeMultiMap<
 
     if (this.isNode(keyOrNodeOrEntryOrRawElement)) return keyOrNodeOrEntryOrRawElement;
 
-    if (this.toEntryFn) {
-      const [key] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
-      if (key) return this.getNodeByKey(key);
-    }
-
     if (this.isEntry(keyOrNodeOrEntryOrRawElement)) {
-      const [key, value] = keyOrNodeOrEntryOrRawElement;
+      const [key, entryValue] = keyOrNodeOrEntryOrRawElement;
       if (key === undefined || key === null) return;
-      else return this.createNode(key, value, 'BLACK', count);
+      if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
+    }
+
+    if (this.toEntryFn) {
+      const [key, entryValue] = this.toEntryFn(keyOrNodeOrEntryOrRawElement as R);
+      if (this.isKey(key)) return this.createNode(key, value ?? entryValue, 'BLACK', count);
     }
 
     if (this.isKey(keyOrNodeOrEntryOrRawElement))
@@ -202,11 +197,6 @@ export class TreeMultiMap<
     return keyOrNodeOrEntryOrRawElement instanceof TreeMultiMapNode;
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -236,11 +226,6 @@ export class TreeMultiMap<
     }
   }
 
-  /**
-   * Time Complexity: O(log n)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -300,7 +285,7 @@ export class TreeMultiMap<
         return results;
       }
     } else {
-      const successor = this.getLeftMost(nodeToDelete.right);
+      const successor = this.getLeftMost(node => node, nodeToDelete.right);
       if (successor) {
         originalColor = successor.color;
         replacementNode = successor.right;
@@ -352,11 +337,6 @@ export class TreeMultiMap<
     return results;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -369,11 +349,6 @@ 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)
@@ -425,11 +400,6 @@ export class TreeMultiMap<
     }
   }
 
-  /**
-   * Time complexity: O(n)
-   * Space complexity: O(n)
-   */
-
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -443,11 +413,6 @@ export class TreeMultiMap<
     return cloned;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -490,11 +455,6 @@ export class TreeMultiMap<
     return undefined;
   }
 
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   */
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

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

@@ -119,11 +119,6 @@ export abstract class AbstractGraph<
 
   abstract getEndsOfEdge(edge: EO): [VO, VO] | undefined;
 
-  /**
-   * Time Complexity: O(1) - Constant time for Map lookup.
-   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-   */
-
   /**
    * Time Complexity: O(1) - Constant time for Map lookup.
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -138,11 +133,6 @@ export abstract class AbstractGraph<
     return this._vertexMap.get(vertexKey) || undefined;
   }
 
-  /**
-   * Time Complexity: O(1) - Constant time for Map lookup.
-   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-   */
-
   /**
    * Time Complexity: O(1) - Constant time for Map lookup.
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -186,11 +176,6 @@ export abstract class AbstractGraph<
 
   abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
 
-  /**
-   * Time Complexity: O(K), where K is the number of vertexMap to be removed.
-   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-   */
-
   /**
    * Time Complexity: O(K), where K is the number of vertexMap to be removed.
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -209,11 +194,6 @@ export abstract class AbstractGraph<
     return removed.length > 0;
   }
 
-  /**
-   * Time Complexity: O(1) - Depends on the implementation in the concrete class.
-   * Space Complexity: O(1) - Depends on the implementation in the concrete class.
-   */
-
   /**
    * Time Complexity: O(1) - Depends on the implementation in the concrete class.
    * Space Complexity: O(1) - Depends on the implementation in the concrete class.
@@ -255,11 +235,6 @@ export abstract class AbstractGraph<
     }
   }
 
-  /**
-   * Time Complexity: O(1) - Constant time for Map and Edge operations.
-   * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-   */
-
   /**
    * Time Complexity: O(1) - Constant time for Map and Edge operations.
    * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -284,11 +259,6 @@ export abstract class AbstractGraph<
     }
   }
 
-  /**
-   * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
-   * Space Complexity: O(P) - Linear space, where P is the number of paths found.
-   */
-
   /**
    * Time Complexity: O(P), where P is the number of paths found (in the worst case, exploring all paths).
    * Space Complexity: O(P) - Linear space, where P is the number of paths found.
@@ -331,11 +301,6 @@ export abstract class AbstractGraph<
     return paths;
   }
 
-  /**
-   * Time Complexity: O(L), where L is the length of the path.
-   * Space Complexity: O(1) - Constant space.
-   */
-
   /**
    * Time Complexity: O(L), where L is the length of the path.
    * Space Complexity: O(1) - Constant space.
@@ -352,11 +317,6 @@ export abstract class AbstractGraph<
     return sum;
   }
 
-  /**
-   * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-   */
-
   /**
    * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
    * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -419,11 +379,6 @@ export abstract class AbstractGraph<
     }
   }
 
-  /**
-   * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
-   */
-
   /**
    * Time Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
    * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm or DFS).
@@ -495,15 +450,6 @@ export abstract class AbstractGraph<
     }
   }
 
-  /**
-   *  Dijkstra algorithm time: O(VE) space: O(VO + EO)
-   */
-
-  /**
-   * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
-   * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
-   */
-
   /**
    * Time Complexity: O(V^2 + E) - Quadratic time in the worst case (no heap optimization).
    * Space Complexity: O(V + E) - Depends on the implementation (Dijkstra's algorithm).
@@ -633,20 +579,6 @@ export abstract class AbstractGraph<
     return { distMap, preMap, seen, paths, minDist, minPath };
   }
 
-  /**
-   *  Dijkstra algorithm time: O(logVE) space: O(VO + EO)
-   *
-   * Dijkstra's algorithm only solves the single-source shortest path problem, while the Bellman-Ford algorithm and Floyd-Warshall algorithm can address shortest paths between all pairs of nodes.
-   * Dijkstra's algorithm is suitable for graphs with non-negative edge weights, whereas the Bellman-Ford algorithm and Floyd-Warshall algorithm can handle negative-weight edgeMap.
-   * The time complexity of Dijkstra's algorithm and the Bellman-Ford algorithm depends on the size of the graph, while the time complexity of the Floyd-Warshall algorithm is O(VO^3), where VO is the number of nodes. For dense graphs, Floyd-Warshall might become slower.
-   *
-   */
-
-  /**
-   * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
-   * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
-   */
-
   /**
    * Time Complexity: O((V + E) * log(V)) - Depends on the implementation (using a binary heap).
    * Space Complexity: O(V + E) - Depends on the implementation (using a binary heap).
@@ -774,12 +706,6 @@ export abstract class AbstractGraph<
     return { distMap, preMap, seen, paths, minDist, minPath };
   }
 
-  /**
-   * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
-   * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
-   * one to rest pairs
-   */
-
   /**
    * Time Complexity: O(V * E) - Quadratic time in the worst case (Bellman-Ford algorithm).
    * Space Complexity: O(V + E) - Depends on the implementation (Bellman-Ford algorithm).
@@ -902,14 +828,6 @@ export abstract class AbstractGraph<
    * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
    */
 
-  /**
-   * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
-   * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
-   * Not support graph with negative weight cycle
-   * all pairs
-   * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edgeMap, and it can simultaneously compute shortest paths between any two nodes.
-   */
-
   /**
    * Time Complexity: O(V^3) - Cubic time (Floyd-Warshall algorithm).
    * Space Complexity: O(V^2) - Quadratic space (Floyd-Warshall algorithm).
@@ -1009,11 +927,6 @@ export abstract class AbstractGraph<
     return [...uniqueCycles].map(cycleString => cycleString[1]);
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1042,11 +955,6 @@ export abstract class AbstractGraph<
     return filtered;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   */
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)