data-structure-typed 1.37.9 → 1.38.1

package/lib/types/helpers.d.ts

@@ -2,3 +2,8 @@ export type Comparator<T> = (a: T, b: T) => number;
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type MapCallback<N> = (node: N) => any;
 export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

package/lib/types/helpers.js

@@ -1 +1,6 @@
-export {};
+export var CP;
+(function (CP) {
+    CP["lt"] = "lt";
+    CP["eq"] = "eq";
+    CP["gt"] = "gt";
+})(CP || (CP = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.37.9",
+  "version": "1.38.1",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -34,7 +34,8 @@
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
     "ci": "env && git fetch --tags && npm run lint && npm run build && npm run update:subs && npm run test && npm run changelog",
-    "publish:subs": "sh scripts/publish_all_subs.sh",
+    "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
+    "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
     "publish:all": "npm run ci && npm publish && npm run publish:subs && npm run publish:docs"
   },
@@ -58,17 +59,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.37.8",
+    "avl-tree-typed": "^1.38.0",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.37.8",
-    "bst-typed": "^1.37.8",
+    "binary-tree-typed": "^1.38.0",
+    "bst-typed": "^1.38.0",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.37.8",
+    "heap-typed": "^1.38.0",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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.

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;
   }
 
   /**
@@ -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.
@@ -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;
 }
 
 /**
@@ -68,33 +68,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 +338,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/hash/hash-map.ts

@@ -8,28 +8,47 @@ import {HashFunction} from '../../types';
  * @license MIT License
  */
 export class HashMap<K, V> {
-  get hashFn(): HashFunction<K> {
-    return this._hashFn;
+  /**
+   * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
+   * multiplier, size, table array, and hash function.
+   * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
+   * buckets or slots available for storing key-value pairs. The default value is 16.
+   * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
+   * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
+   * load factor is reached, the hash table will
+   * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
+   * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
+   * default hash function converts the key to a string, calculates the sum of the
+   */
+  constructor(initialCapacity = 16, loadFactor = 0.75, hashFn?: HashFunction<K>) {
+    this._initialCapacity = initialCapacity;
+    this._loadFactor = loadFactor;
+    this._capacityMultiplier = 2;
+    this._size = 0;
+    this._table = new Array(initialCapacity);
+    this._hashFn =
+      hashFn ||
+      ((key: K) => {
+        const strKey = String(key);
+        let hash = 0;
+        for (let i = 0; i < strKey.length; i++) {
+          hash += strKey.charCodeAt(i);
+        }
+        return hash % this.table.length;
+      });
   }
 
-  set hashFn(value: HashFunction<K>) {
-    this._hashFn = value;
-  }
-  get table(): Array<Array<[K, V]>> {
-    return this._table;
-  }
+  private _initialCapacity: number;
 
-  set table(value: Array<Array<[K, V]>>) {
-    this._table = value;
+  get initialCapacity(): number {
+    return this._initialCapacity;
   }
 
-  get capacityMultiplier(): number {
-    return this._capacityMultiplier;
+  set initialCapacity(value: number) {
+    this._initialCapacity = value;
   }
 
-  set capacityMultiplier(value: number) {
-    this._capacityMultiplier = value;
-  }
+  private _loadFactor: number;
 
   get loadFactor(): number {
     return this._loadFactor;
@@ -39,14 +58,18 @@ export class HashMap<K, V> {
     this._loadFactor = value;
   }
 
-  get initialCapacity(): number {
-    return this._initialCapacity;
+  private _capacityMultiplier: number;
+
+  get capacityMultiplier(): number {
+    return this._capacityMultiplier;
   }
 
-  set initialCapacity(value: number) {
-    this._initialCapacity = value;
+  set capacityMultiplier(value: number) {
+    this._capacityMultiplier = value;
   }
 
+  private _size: number;
+
   get size(): number {
     return this._size;
   }
@@ -55,68 +78,24 @@ export class HashMap<K, V> {
     this._size = value;
   }
 
-  private _initialCapacity: number;
-  private _loadFactor: number;
-  private _capacityMultiplier: number;
-  private _size: number;
   private _table: Array<Array<[K, V]>>;
-  private _hashFn: HashFunction<K>;
 
-  /**
-   * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
-   * multiplier, size, table array, and hash function.
-   * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
-   * buckets or slots available for storing key-value pairs. The default value is 16.
-   * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
-   * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
-   * load factor is reached, the hash table will
-   * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
-   * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
-   * default hash function converts the key to a string, calculates the sum of the
-   */
-  constructor(initialCapacity = 16, loadFactor = 0.75, hashFn?: HashFunction<K>) {
-    this._initialCapacity = initialCapacity;
-    this._loadFactor = loadFactor;
-    this._capacityMultiplier = 2;
-    this._size = 0;
-    this._table = new Array(initialCapacity);
-    this._hashFn =
-      hashFn ||
-      ((key: K) => {
-        const strKey = String(key);
-        let hash = 0;
-        for (let i = 0; i < strKey.length; i++) {
-          hash += strKey.charCodeAt(i);
-        }
-        return hash % this.table.length;
-      });
+  get table(): Array<Array<[K, V]>> {
+    return this._table;
   }
 
-  private _hash(key: K): number {
-    return this._hashFn(key);
+  set table(value: Array<Array<[K, V]>>) {
+    this._table = value;
   }
 
-  /**
-   * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-   * rehashing the key-value pairs from the old table into the new table.
-   * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-   * the number of buckets that the new table should have.
-   */
-  private resizeTable(newCapacity: number): void {
-    const newTable = new Array(newCapacity);
-    for (const bucket of this._table) {
-      // Note that this is this._table
-      if (bucket) {
-        for (const [key, value] of bucket) {
-          const newIndex = this._hash(key) % newCapacity;
-          if (!newTable[newIndex]) {
-            newTable[newIndex] = [];
-          }
-          newTable[newIndex].push([key, value]);
-        }
-      }
-    }
-    this._table = newTable; // Again, here is this._table
+  private _hashFn: HashFunction<K>;
+
+  get hashFn(): HashFunction<K> {
+    return this._hashFn;
+  }
+
+  set hashFn(value: HashFunction<K>) {
+    this._hashFn = value;
   }
 
   set(key: K, value: V): void {
@@ -200,4 +179,31 @@ export class HashMap<K, V> {
   isEmpty(): boolean {
     return this.size === 0;
   }
+
+  private _hash(key: K): number {
+    return this._hashFn(key);
+  }
+
+  /**
+   * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
+   * rehashing the key-value pairs from the old table into the new table.
+   * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
+   * the number of buckets that the new table should have.
+   */
+  private resizeTable(newCapacity: number): void {
+    const newTable = new Array(newCapacity);
+    for (const bucket of this._table) {
+      // Note that this is this._table
+      if (bucket) {
+        for (const [key, value] of bucket) {
+          const newIndex = this._hash(key) % newCapacity;
+          if (!newTable[newIndex]) {
+            newTable[newIndex] = [];
+          }
+          newTable[newIndex].push([key, value]);
+        }
+      }
+    }
+    this._table = newTable; // Again, here is this._table
+  }
 }