linked-list-typed 1.43.1 → 1.43.3

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

@@ -10,10 +10,7 @@ import {BiTreeDeleteResult, BTNCallback, CP, FamilyPosition, IterationType} from
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
-export class TreeMultimapNode<
-  V = any,
-  N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>
-> extends AVLTreeNode<V, N> {
+export class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
   count: number;
 
   /**
@@ -160,52 +157,6 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
    */
 
-  /**
-   * 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 {BTNKey | 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
-   * (`BTNKey`).
-   * @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: BTNKey | N | undefined): N | undefined {
-    parent = this.ensureNotKey(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;
-    }
-  }
-
-  /**
-   * Time Complexity: O(k log n) - 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.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   */
-
   /**
    * Time Complexity: O(k log n) - 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.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -241,8 +192,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * Time Complexity: O(n log 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.
-   * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
+   * Time Complexity: O(k log n) - 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.
+   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
    */
 
   /**
@@ -295,8 +246,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
-   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   * Time Complexity: O(n log 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.
+   * Space Complexity: O(n) - linear space, as it creates an array to store the sorted nodes.
    */
 
   /**
@@ -330,7 +281,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     if (!curr) return deletedResult;
 
     const parent: N | undefined = curr?.parent ? curr.parent : undefined;
-    let needBalanced: N | undefined = undefined,orgCurrent: N | undefined = curr;
+    let needBalanced: N | undefined = undefined,
+      orgCurrent: N | undefined = curr;
 
     if (curr.count > 1 && !ignoreCount) {
       curr.count--;
@@ -377,6 +329,11 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     return deletedResult;
   }
 
+  /**
+   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The delete method of the superclass (AVLTree) has logarithmic time complexity.
+   * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
+   */
+
   /**
    * The clear() function clears the contents of a data structure and sets the count to zero.
    */
@@ -385,6 +342,47 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     this._count = 0;
   }
 
+  /**
+   * 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 {BTNKey | 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
+   * (`BTNKey`).
+   * @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: BTNKey | N | undefined): N | undefined {
+    parent = this.ensureNotKey(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 `_swap` function swaps the key, value, count, and height properties between two nodes.
    * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
@@ -394,7 +392,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
    * if either `srcNode` or `destNode` is undefined.
    */
-  protected _swap(srcNode: BTNKey | N | undefined, destNode:BTNKey | N | undefined): N | undefined{
+  protected _swap(srcNode: BTNKey | N | undefined, destNode: BTNKey | N | undefined): N | undefined {
     srcNode = this.ensureNotKey(srcNode);
     destNode = this.ensureNotKey(destNode);
     if (srcNode && destNode) {
@@ -416,6 +414,6 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
 
       return destNode;
     }
-    return  undefined;
+    return undefined;
   }
-}
+}

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

@@ -64,8 +64,7 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO>
-{
+> implements IGraph<V, E, VO, EO> {
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -496,7 +495,7 @@ export abstract class AbstractGraph<
    * 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).
    *
@@ -515,12 +514,7 @@ export abstract class AbstractGraph<
    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
    * @returns The function `dijkstraWithoutHeap` returns an object of type `DijkstraResult<VO>`.
    */
-  dijkstraWithoutHeap(
-    src: VO | VertexKey,
-    dest?: VO | VertexKey | null,
-    getMinDist?: boolean,
-    genPaths?: boolean
-  ): DijkstraResult<VO> {
+  dijkstraWithoutHeap(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
@@ -643,7 +637,7 @@ export abstract class AbstractGraph<
    * 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).
    *
@@ -663,12 +657,7 @@ export abstract class AbstractGraph<
    * shortest paths from the source vertex to all other vertices in the graph. If `genPaths
    * @returns The function `dijkstra` returns an object of type `DijkstraResult<VO>`.
    */
-  dijkstra(
-    src: VO | VertexKey,
-    dest?: VO | VertexKey | null,
-    getMinDist?: boolean,
-    genPaths?: boolean
-  ): DijkstraResult<VO> {
+  dijkstra(src: VO | VertexKey, dest?: VO | VertexKey | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<VO> {
     if (getMinDist === undefined) getMinDist = false;
     if (genPaths === undefined) genPaths = false;
 
@@ -993,12 +982,7 @@ export abstract class AbstractGraph<
    * are arrays of vertices that form cycles within the SCCs.
    * @returns The function `tarjan` returns an object with the following properties:
    */
-  tarjan(
-    needCutVertexes: boolean = false,
-    needBridges: boolean = false,
-    needSCCs: boolean = true,
-    needCycles: boolean = false
-  ) {
+  tarjan(needCutVertexes: boolean = false, needBridges: boolean = false, needSCCs: boolean = true, needCycles: boolean = false) {
     // !! in undirected graph we will not let child visit parent when dfs
     // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
     // !! bridge: low(child) > dfn(cur)

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

@@ -45,15 +45,9 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
   }
 }
 
-export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+export class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V> = DirectedVertex<V>, EO extends DirectedEdge<E> = DirectedEdge<E>>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -591,4 +585,4 @@ export class DirectedGraph<
       return false;
     }
   }
-}
+}

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

@@ -40,12 +40,12 @@ export class MapEdge<E = any> extends DirectedEdge<E> {
   }
 }
 
-export class MapGraph<
-  V = any,
-  E = any,
-  VO extends MapVertex<V> = MapVertex<V>,
-  EO extends MapEdge<E> = MapEdge<E>
-> extends DirectedGraph<V, E, VO, EO> {
+export class MapGraph<V = any, E = any, VO extends MapVertex<V> = MapVertex<V>, EO extends MapEdge<E> = MapEdge<E>> extends DirectedGraph<
+  V,
+  E,
+  VO,
+  EO
+> {
   /**
    * The constructor function initializes the origin and bottomRight properties of a MapGraphCoordinate object.
    * @param {MapGraphCoordinate} origin - The `origin` parameter is a `MapGraphCoordinate` object that represents the

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

@@ -49,8 +49,7 @@ export class UndirectedGraph<
     EO extends UndirectedEdge<E> = UndirectedEdge<E>
   >
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor initializes a new Map object to store edges.
    */

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

@@ -445,7 +445,6 @@ export class FibonacciHeap<E> {
     return this.push(element);
   }
 
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -473,7 +472,6 @@ export class FibonacciHeap<E> {
     return this;
   }
 
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -743,10 +741,7 @@ export class FibonacciHeap<E> {
   protected consolidate(): void {
     const A: (FibonacciHeapNode<E> | undefined)[] = new Array(this.size);
     const nodes = this.consumeLinkedList(this.root);
-    let x: FibonacciHeapNode<E> | undefined,
-      y: FibonacciHeapNode<E> | undefined,
-      d: number,
-      t: FibonacciHeapNode<E> | undefined;
+    let x: FibonacciHeapNode<E> | undefined, y: FibonacciHeapNode<E> | undefined, d: number, t: FibonacciHeapNode<E> | undefined;
 
     for (const node of nodes) {
       x = node;

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

@@ -342,4 +342,4 @@ export class Trie {
     }
     return str;
   }
-}
+}

package/src/interfaces/binary-tree.ts

@@ -1,5 +1,5 @@
 import {BinaryTreeNode} from '../data-structures';
-import {BiTreeDeleteResult, BinaryTreeNodeNested, BTNCallback, BTNKey} from '../types';
+import {BinaryTreeNodeNested, BiTreeDeleteResult, BTNCallback, BTNKey} from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
   createNode(key: BTNKey, value?: N['value']): N;

package/src/types/utils/validate-type.ts

@@ -16,20 +16,6 @@ export type ObjectWithNumberKey = {
   key: number;
 };
 
-export type RestrictValByKey =
-  | NonNumberNonObjectButDefined
-  | ObjectWithoutKey
-  | ObjectWithNonNumberKey
-  | ObjectWithNumberKey;
+export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;
 
-export type DummyAny =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined
-  | object
-  | symbol
-  | void
-  | ((...args: []) => any)
-  | never;
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | ((...args: []) => any) | never;