heap-typed 1.38.0 → 1.38.2

package/dist/index.js

@@ -22,6 +22,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * @license MIT License
  */
 // export { Heap, MaxHeap, MinHeap } from 'data-structure-typed';
-__exportStar(require("data-structure-typed/src/data-structures/heap"), exports);
-__exportStar(require("data-structure-typed/src/types/data-structures/heap"), exports);
-__exportStar(require("data-structure-typed/src/types/helpers"), exports);
+__exportStar(require("./data-structures/heap"), exports);
+__exportStar(require("./types/data-structures/heap"), exports);
+__exportStar(require("./types/helpers"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heap-typed",
-  "version": "1.38.0",
+  "version": "1.38.2",
   "description": "Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -128,8 +128,5 @@
     "ts-jest": "^29.1.1",
     "typedoc": "^0.25.1",
     "typescript": "^4.9.5"
-  },
-  "dependencies": {
-    "data-structure-typed": "^1.38.0"
   }
 }

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

@@ -32,33 +32,6 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
     super(options);
   }
 
-  /**
-   * The function swaps the key, value, and height properties between two nodes in a binary tree.
-   * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
-   * with the `destNode`.
-   * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-   * from the source node (`srcNode`) will be swapped to.
-   * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-   */
-  protected override _swap(srcNode: N, destNode: N): N {
-    const {key, val, height} = destNode;
-    const tempNode = this.createNode(key, val);
-
-    if (tempNode) {
-      tempNode.height = height;
-
-      destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
-      destNode.height = srcNode.height;
-
-      srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
-      srcNode.height = tempNode.height;
-    }
-
-    return destNode;
-  }
-
   /**
    * The function creates a new AVL tree node with the specified key and value.
    * @param {BinaryTreeNodeKey} key - The key parameter is the key value that will be associated with
@@ -105,6 +78,33 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
     return deletedResults;
   }
 
+  /**
+   * The function swaps the key, value, and height properties between two nodes in a binary tree.
+   * @param {N} srcNode - The `srcNode` parameter represents the source node that needs to be swapped
+   * with the `destNode`.
+   * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+   * from the source node (`srcNode`) will be swapped to.
+   * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+   */
+  protected override _swap(srcNode: N, destNode: N): N {
+    const {key, val, height} = destNode;
+    const tempNode = this.createNode(key, val);
+
+    if (tempNode) {
+      tempNode.height = height;
+
+      destNode.key = srcNode.key;
+      destNode.val = srcNode.val;
+      destNode.height = srcNode.height;
+
+      srcNode.key = tempNode.key;
+      srcNode.val = tempNode.val;
+      srcNode.height = tempNode.height;
+    }
+
+    return destNode;
+  }
+
   /**
    * The function calculates the balance factor of a node in a binary tree.
    * @param {N} node - The parameter "node" represents a node in a binary tree data structure.
@@ -152,7 +152,7 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
       // Balance Restoration: If a balance issue is discovered after inserting a node, it requires balance restoration operations. Balance restoration includes four basic cases where rotation operations need to be performed to fix the balance:
       switch (
         this._balanceFactor(A) // second O(1)
-      ) {
+        ) {
         case -2:
           if (A && A.left) {
             if (this._balanceFactor(A.left) <= 0) {

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

@@ -17,7 +17,7 @@ export class BinaryIndexedTree {
    * @param  - - `frequency`: The default frequency value. It is optional and has a default
    * value of 0.
    */
-  constructor({frequency = 0, max}: {frequency?: number; max: number}) {
+  constructor({frequency = 0, max}: { frequency?: number; max: number }) {
     this._freq = frequency;
     this._max = max;
     this._freqMap = {0: 0};

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

@@ -26,16 +26,6 @@ import {Queue} from '../queue';
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
 export class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> = BinaryTreeNodeNested<V>> {
-  /**
-   * Creates a new instance of BinaryTreeNode.
-   * @param {BinaryTreeNodeKey} key - The key associated with the node.
-   * @param {V} val - The value stored in the node.
-   */
-  constructor(key: BinaryTreeNodeKey, val?: V) {
-    this.key = key;
-    this.val = val;
-  }
-
   /**
    * The key associated with the node.
    */
@@ -46,6 +36,21 @@ export class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> =
    */
   val: V | undefined;
 
+  /**
+   * The parent node of the current node.
+   */
+  parent: FAMILY | null | undefined;
+
+  /**
+   * Creates a new instance of BinaryTreeNode.
+   * @param {BinaryTreeNodeKey} key - The key associated with the node.
+   * @param {V} val - The value stored in the node.
+   */
+  constructor(key: BinaryTreeNodeKey, val?: V) {
+    this.key = key;
+    this.val = val;
+  }
+
   private _left: FAMILY | null | undefined;
 
   /**
@@ -86,11 +91,6 @@ export class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> =
     this._right = v;
   }
 
-  /**
-   * The parent node of the current node.
-   */
-  parent: FAMILY | null | undefined;
-
   /**
    * Get the position of the node within its family.
    * @returns {FamilyPosition} - The family position of the node.
@@ -128,6 +128,8 @@ export class BinaryTreeNode<V = any, FAMILY extends BinaryTreeNode<V, FAMILY> =
  * @template N - The type of the binary tree's nodes.
  */
 export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> implements IBinaryTree<N> {
+  private _loopType: IterationType = IterationType.ITERATIVE;
+
   /**
    * Creates a new instance of BinaryTree.
    * @param {BinaryTreeOptions} [options] - The options for the binary tree.
@@ -139,16 +141,6 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     }
   }
 
-  /**
-   * Creates a new instance of BinaryTreeNode with the given key and value.
-   * @param {BinaryTreeNodeKey} key - The key for the new node.
-   * @param {N['val']} val - The value for the new node.
-   * @returns {N} - The newly created BinaryTreeNode.
-   */
-  createNode(key: BinaryTreeNodeKey, val?: N['val']): N {
-    return new BinaryTreeNode<N['val'], N>(key, val) as N;
-  }
-
   private _root: N | null = null;
 
   /**
@@ -167,8 +159,6 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     return this._size;
   }
 
-  private _loopType: IterationType = IterationType.ITERATIVE;
-
   /**
    * Get the iteration type used in the binary tree.
    */
@@ -185,24 +175,13 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
   }
 
   /**
-   * Swap the data of two nodes in the binary tree.
-   * @param {N} srcNode - The source node to swap.
-   * @param {N} destNode - The destination node to swap.
-   * @returns {N} - The destination node after the swap.
+   * Creates a new instance of BinaryTreeNode with the given key and value.
+   * @param {BinaryTreeNodeKey} key - The key for the new node.
+   * @param {N['val']} val - The value for the new node.
+   * @returns {N} - The newly created BinaryTreeNode.
    */
-  protected _swap(srcNode: N, destNode: N): N {
-    const {key, val} = destNode;
-    const tempNode = this.createNode(key, val);
-
-    if (tempNode) {
-      destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
-
-      srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
-    }
-
-    return destNode;
+  createNode(key: BinaryTreeNodeKey, val?: N['val']): N {
+    return new BinaryTreeNode<N['val'], N>(key, val) as N;
   }
 
   /**
@@ -428,7 +407,7 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
         return -1;
       }
 
-      const stack: {node: N; depth: number}[] = [{node: beginRoot, depth: 0}];
+      const stack: { node: N; depth: number }[] = [{node: beginRoot, depth: 0}];
       let maxHeight = 0;
 
       while (stack.length > 0) {
@@ -449,8 +428,6 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     }
   }
 
-  protected _defaultCallbackByKey: MapCallback<N> = node => node.key;
-
   /**
    * The `getMinHeight` function calculates the minimum height of a binary tree using either a
    * recursive or iterative approach.
@@ -865,7 +842,7 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
       _traverse(beginRoot);
     } else {
       // 0: visit, 1: print
-      const stack: {opt: 0 | 1; node: N | null | undefined}[] = [{opt: 0, node: beginRoot}];
+      const stack: { opt: 0 | 1; node: N | null | undefined }[] = [{opt: 0, node: beginRoot}];
 
       while (stack.length > 0) {
         const cur = stack.pop();
@@ -902,8 +879,6 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     return ans;
   }
 
-  // --- start additional methods ---
-
   /**
    * The bfs function performs a breadth-first search traversal on a binary tree, executing a callback
    * function on each node.
@@ -973,13 +948,7 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     }
   }
 
-  /**
-   * Time complexity is O(n)
-   * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-   * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-   * the tree's structure should be restored to its original state to maintain the tree's integrity.
-   * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-   */
+  // --- start additional methods ---
 
   /**
    * The `morris` function performs a depth-first traversal of a binary tree using the Morris traversal
@@ -1080,6 +1049,37 @@ export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode>
     return ans;
   }
 
+  /**
+   * Swap the data of two nodes in the binary tree.
+   * @param {N} srcNode - The source node to swap.
+   * @param {N} destNode - The destination node to swap.
+   * @returns {N} - The destination node after the swap.
+   */
+  protected _swap(srcNode: N, destNode: N): N {
+    const {key, val} = destNode;
+    const tempNode = this.createNode(key, val);
+
+    if (tempNode) {
+      destNode.key = srcNode.key;
+      destNode.val = srcNode.val;
+
+      srcNode.key = tempNode.key;
+      srcNode.val = tempNode.val;
+    }
+
+    return destNode;
+  }
+
+  /**
+   * Time complexity is O(n)
+   * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+   * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+   * the tree's structure should be restored to its original state to maintain the tree's integrity.
+   * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+   */
+
+  protected _defaultCallbackByKey: MapCallback<N> = node => node.key;
+
   /**
    * The function `_addTo` adds a new node to a binary tree if there is an available position.
    * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to

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

@@ -153,22 +153,26 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
     function hasNoNull(arr: (BinaryTreeNodeKey | null)[] | (N | null)[]): arr is BinaryTreeNodeKey[] | N[] {
       return arr.indexOf(null) === -1;
     }
+
     if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
     const combinedArr: [BinaryTreeNodeKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
+
     function isNodeOrNullTuple(arr: [BinaryTreeNodeKey | N, N['val']][]): arr is [N, N['val']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
+
     function isBinaryTreeKeyOrNullTuple(
       arr: [BinaryTreeNodeKey | N, N['val']][]
     ): arr is [BinaryTreeNodeKey, N['val']][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }
+
     let sortedKeysOrNodes: (number | N | null)[] = [],
       sortedData: (N['val'] | undefined)[] | undefined = [];
 

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

@@ -6,13 +6,13 @@ export class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNo
   V,
   FAMILY
 > {
-  private _color: RBColor;
-
   constructor(key: BinaryTreeNodeKey, val?: V) {
     super(key, val);
     this._color = RBColor.RED;
   }
 
+  private _color: RBColor;
+
   get color(): RBColor {
     return this._color;
   }

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

@@ -14,6 +14,8 @@ export class TreeMultisetNode<
   V = any,
   FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>
 > extends AVLTreeNode<V, FAMILY> {
+  count: number;
+
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -28,8 +30,6 @@ export class TreeMultisetNode<
     super(key, val);
     this.count = count;
   }
-
-  count: number;
 }
 
 /**
@@ -37,8 +37,7 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode>
   extends AVLTree<N>
-  implements IBinaryTree<N>
-{
+  implements IBinaryTree<N> {
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -68,33 +67,6 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
     return new TreeMultisetNode(key, val, count) as N;
   }
 
-  /**
-   * The function swaps the values of two nodes in a binary tree.
-   * @param {N} srcNode - The source node that needs to be swapped with the destination node.
-   * @param {N} destNode - The `destNode` parameter represents the destination node where the values
-   * from `srcNode` will be swapped into.
-   * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
-   */
-  protected override _swap(srcNode: N, destNode: N): N {
-    const {key, val, count, height} = destNode;
-    const tempNode = this.createNode(key, val, count);
-    if (tempNode) {
-      tempNode.height = height;
-
-      destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
-      destNode.count = srcNode.count;
-      destNode.height = srcNode.height;
-
-      srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
-      srcNode.count = tempNode.count;
-      srcNode.height = tempNode.height;
-    }
-
-    return destNode;
-  }
-
   /**
    * The `add` function adds a new node to a binary search tree, updating the count if the key already
    * exists, and balancing the tree if necessary.
@@ -365,6 +337,33 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
     this._setCount(0);
   }
 
+  /**
+   * The function swaps the values of two nodes in a binary tree.
+   * @param {N} srcNode - The source node that needs to be swapped with the destination node.
+   * @param {N} destNode - The `destNode` parameter represents the destination node where the values
+   * from `srcNode` will be swapped into.
+   * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
+   */
+  protected override _swap(srcNode: N, destNode: N): N {
+    const {key, val, count, height} = destNode;
+    const tempNode = this.createNode(key, val, count);
+    if (tempNode) {
+      tempNode.height = height;
+
+      destNode.key = srcNode.key;
+      destNode.val = srcNode.val;
+      destNode.count = srcNode.count;
+      destNode.height = srcNode.height;
+
+      srcNode.key = tempNode.key;
+      srcNode.val = tempNode.val;
+      srcNode.count = tempNode.count;
+      srcNode.height = tempNode.height;
+    }
+
+    return destNode;
+  }
+
   /**
    * The function sets the value of the "_count" property.
    * @param {number} v - number

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

@@ -105,8 +105,7 @@ export abstract class AbstractEdge<V = any> {
 export abstract class AbstractGraph<
   V extends AbstractVertex<any> = AbstractVertex<any>,
   E extends AbstractEdge<any> = AbstractEdge<any>
-> implements IGraph<V, E>
-{
+> implements IGraph<V, E> {
   private _vertices: Map<VertexKey, V> = new Map<VertexKey, V>();
 
   get vertices(): Map<VertexKey, V> {
@@ -554,14 +553,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-      distMap.forEach((d, v) => {
-        if (v !== srcVertex) {
-          if (d < minDist) {
-            minDist = d;
-            if (genPaths) minDest = v;
-          }
+    distMap.forEach((d, v) => {
+      if (v !== srcVertex) {
+        if (d < minDist) {
+          minDist = d;
+          if (genPaths) minDest = v;
         }
-      });
+      }
+    });
 
     genPaths && getPaths(minDest);
 
@@ -623,7 +622,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{key: number; val: V}>((a, b) => a.key - b.key);
+    const heap = new PriorityQueue<{ key: number; val: V }>((a, b) => a.key - b.key);
     heap.add({key: 0, val: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -852,7 +851,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (V | null)[][]} {
+  floyd(): { costs: number[][]; predecessor: (V | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 

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

@@ -64,8 +64,7 @@ export class DirectedEdge<V = any> extends AbstractEdge<V> {
 
 export class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E>
-{
+  implements IGraph<V, E> {
   /**
    * The constructor function initializes an instance of a class.
    */

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

@@ -51,12 +51,11 @@ export class UndirectedEdge<V = number> extends AbstractEdge<V> {
 }
 
 export class UndirectedGraph<
-    V extends UndirectedVertex<any> = UndirectedVertex,
-    E extends UndirectedEdge<any> = UndirectedEdge
-  >
+  V extends UndirectedVertex<any> = UndirectedVertex,
+  E extends UndirectedEdge<any> = UndirectedEdge
+>
   extends AbstractGraph<V, E>
-  implements IGraph<V, E>
-{
+  implements IGraph<V, E> {
   /**
    * The constructor initializes a new Map object to store edges.
    */