min-heap-typed 1.39.4 → 1.39.6

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

@@ -12,8 +12,8 @@ import {IBinaryTree} from '../../interfaces';
 import {Queue} from '../queue';
 
 export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
-  constructor(key: BTNKey, val?: V) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V) {
+    super(key, value);
   }
 }
 
@@ -41,12 +41,12 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * The function creates a new binary search tree node with the given key and value.
    * @param {BTNKey} key - The key parameter is the key value that will be associated with
    * the new node. It is used to determine the position of the node in the binary search tree.
-   * @param [val] - The parameter `val` is an optional value that can be assigned to the node. It
+   * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
    * represents the value associated with the node in a binary search tree.
    * @returns a new instance of the BSTNode class with the specified key and value.
    */
-  override createNode(key: BTNKey, val?: V): N {
-    return new BSTNode<V, N>(key, val) as N;
+  override createNode(key: BTNKey, value?: V): N {
+    return new BSTNode<V, N>(key, value) as N;
   }
 
   /**
@@ -54,19 +54,19 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * into the tree.
    * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
    * `BTNKey` (which can be a number or a string), a `BSTNode` object, or `null`.
-   * @param [val] - The `val` parameter is the value to be assigned to the new node being added to the
+   * @param [value] - The `value` parameter is the value to be assigned to the new node being added to the
    * binary search tree.
    * @returns the inserted node (N) if it was successfully added to the binary search tree. If the node
    * was not added or if the parameters were invalid, it returns null or undefined.
    */
-  override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
     // TODO support node as a parameter
     let inserted: N | null = null;
     let newNode: N | null = null;
     if (keyOrNode instanceof BSTNode) {
       newNode = keyOrNode;
     } else if (typeof keyOrNode === 'number') {
-      newNode = this.createNode(keyOrNode, val);
+      newNode = this.createNode(keyOrNode, value);
     } else if (keyOrNode === null) {
       newNode = null;
     }
@@ -81,7 +81,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
         if (cur !== null && newNode !== null) {
           if (this._compare(cur.key, newNode.key) === CP.eq) {
             if (newNode) {
-              cur.val = newNode.val;
+              cur.value = newNode.value;
             }
             //Duplicates are not accepted.
             traversing = false;
@@ -128,7 +128,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
   /**
    * The `addMany` function is used to efficiently add multiple nodes to a binary search tree while
    * maintaining balance.
-   * @param {[BTNKey | N, N['val']][]} keysOrNodes - The `arr` parameter in the `addMany` function
+   * @param {[BTNKey | N, N['value']][]} keysOrNodes - The `arr` parameter in the `addMany` function
    * represents an array of keys or nodes that need to be added to the binary search tree. It can be an
    * array of `BTNKey` or `N` (which represents the node type in the binary search tree) or
    * `null
@@ -154,15 +154,15 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BTNKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BTNKey | N, N['value']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
 
-    function isNodeOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [N, N['val']][] {
+    function isNodeOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [N, N['value']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
       return false;
     }
 
-    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['val']][]): arr is [BTNKey, N['val']][] {
+    function isBinaryTreeKeyOrNullTuple(arr: [BTNKey | N, N['value']][]): arr is [BTNKey, N['value']][] {
       for (const [keyOrNode] of arr) if (typeof keyOrNode === 'number') return true;
       return false;
     }
@@ -178,7 +178,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       throw new Error('Invalid input keysOrNodes');
     }
     sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
-    sortedData = sorted.map(([, val]) => val);
+    sortedData = sorted.map(([, value]) => value);
     const recursive = (arr: (BTNKey | null | N)[], data?: (V | undefined)[]) => {
       if (arr.length === 0) return;
 
@@ -426,7 +426,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.val);
+        this.add(midNode.key, midNode.value);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -442,7 +442,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.key, midNode.val);
+            this.add(midNode.key, midNode.value);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }

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

@@ -3,8 +3,8 @@ import {IBinaryTree} from '../../interfaces';
 import {BST, BSTNode} from './bst';
 
 export class RBTreeNode<V = any, N extends RBTreeNode<V, N> = RBTreeNodeNested<V>> extends BSTNode<V, N> {
-  constructor(key: BTNKey, val?: V) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V) {
+    super(key, value);
     this._color = RBColor.RED;
   }
 
@@ -27,12 +27,12 @@ export class RBTree<V, N extends RBTreeNode<V, N> = RBTreeNode<V, RBTreeNodeNest
     super(options);
   }
 
-  override createNode(key: BTNKey, val?: V): N {
-    return new RBTreeNode(key, val) as N;
+  override createNode(key: BTNKey, value?: V): N {
+    return new RBTreeNode(key, value) as N;
   }
 
-  // override add(keyOrNode: BTNKey | N | null, val?: V): N | null | undefined {
-  //   const inserted = super.add(keyOrNode, val);
+  // override add(keyOrNode: BTNKey | N | null, value?: V): N | null | undefined {
+  //   const inserted = super.add(keyOrNode, value);
   //   if (inserted) this._fixInsertViolation(inserted);
   //   return inserted;
   // }

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

@@ -9,11 +9,11 @@
 import type {SegmentTreeNodeVal} from '../../types';
 
 export class SegmentTreeNode {
-  constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
+  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null) {
     this._start = start;
     this._end = end;
     this._sum = sum;
-    this._val = val || null;
+    this._value = value || null;
   }
 
   private _start = 0;
@@ -35,14 +35,14 @@ export class SegmentTreeNode {
     this._end = v;
   }
 
-  private _val: SegmentTreeNodeVal | null = null;
+  private _value: SegmentTreeNodeVal | null = null;
 
-  get val(): SegmentTreeNodeVal | null {
-    return this._val;
+  get value(): SegmentTreeNodeVal | null {
+    return this._value;
   }
 
-  set val(v: SegmentTreeNodeVal | null) {
-    this._val = v;
+  set value(v: SegmentTreeNodeVal | null) {
+    this._value = v;
   }
 
   private _sum = 0;
@@ -154,30 +154,30 @@ export class SegmentTree {
    * updated.
    * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
    * the `SegmentTreeNode` at the specified `index`.
-   * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+   * @param {SegmentTreeNodeVal} [value] - The `value` parameter is an optional value that can be assigned to the `value`
    * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
-   * cur.val = val;` and pass a value for `val` in the
+   * cur.value = value;` and pass a value for `value` in the
    * @returns The function does not return anything.
    */
-  updateNode(index: number, sum: number, val?: SegmentTreeNodeVal) {
+  updateNode(index: number, sum: number, value?: SegmentTreeNodeVal) {
     const root = this.root || null;
     if (!root) {
       return;
     }
-    const dfs = (cur: SegmentTreeNode, index: number, sum: number, val?: SegmentTreeNodeVal) => {
+    const dfs = (cur: SegmentTreeNode, index: number, sum: number, value?: SegmentTreeNodeVal) => {
       if (cur.start === cur.end && cur.start === index) {
         cur.sum = sum;
-        if (val !== undefined) cur.val = val;
+        if (value !== undefined) cur.value = value;
         return;
       }
       const mid = cur.start + Math.floor((cur.end - cur.start) / 2);
       if (index <= mid) {
         if (cur.left) {
-          dfs(cur.left, index, sum, val);
+          dfs(cur.left, index, sum, value);
         }
       } else {
         if (cur.right) {
-          dfs(cur.right, index, sum, val);
+          dfs(cur.right, index, sum, value);
         }
       }
       if (cur.left && cur.right) {
@@ -185,7 +185,7 @@ export class SegmentTree {
       }
     };
 
-    dfs(root, index, sum, val);
+    dfs(root, index, sum, value);
   }
 
   /**

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

@@ -20,14 +20,14 @@ export class TreeMultisetNode<
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
    * of the binary tree node.
-   * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
+   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
    * tree node. If no value is provided, it will be `undefined`.
    * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
    * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
    * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(key: BTNKey, val?: V, count = 1) {
-    super(key, val);
+  constructor(key: BTNKey, value?: V, count = 1) {
+    super(key, value);
     this.count = count;
   }
 }
@@ -59,13 +59,13 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * The function creates a new BSTNode with the given key, value, and count.
    * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
    * distinguish one node from another in the tree.
-   * @param {N} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+   * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
    * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
    * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(key: BTNKey, val?: V, count?: number): N {
-    return new TreeMultisetNode(key, val, count) as N;
+  override createNode(key: BTNKey, value?: V, count?: number): N {
+    return new TreeMultisetNode(key, value, count) as N;
   }
 
   /**
@@ -74,22 +74,22 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @param {BTNKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a
    * `BTNKey` (which represents the key of the node to be added), a `N` (which represents a
    * node to be added), or `null` (which represents a null node).
-   * @param [val] - The `val` parameter represents the value associated with the key that is being
+   * @param [value] - The `value` parameter represents the value associated with the key that is being
    * added to the binary tree.
    * @param [count=1] - The `count` parameter represents the number of occurrences of the key/value
    * pair that will be added to the binary tree. It has a default value of 1, which means that if no
    * count is specified, the default count will be 1.
    * @returns The function `add` returns a value of type `N | null | undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null, val?: V, count = 1): N | null | undefined {
+  override add(keyOrNode: BTNKey | N | null, value?: V, count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
     if (keyOrNode instanceof TreeMultisetNode) {
-      newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
+      newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
     } else if (keyOrNode === null) {
       newNode = null;
     } else {
-      newNode = this.createNode(keyOrNode, val, count);
+      newNode = this.createNode(keyOrNode, value, count);
     }
     if (!this.root) {
       this._setRoot(newNode);
@@ -103,7 +103,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         if (cur) {
           if (newNode) {
             if (this._compare(cur.key, newNode.key) === CP.eq) {
-              cur.val = newNode.val;
+              cur.value = newNode.value;
               cur.count += newNode.count;
               this._setCount(this.count + newNode.count);
               traversing = false;
@@ -199,7 +199,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       const keyOrNode = keysOrNodes[i];
 
       if (keyOrNode instanceof TreeMultisetNode) {
-        inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
+        inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
         continue;
       }
 
@@ -233,7 +233,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.val, midNode.count);
+        this.add(midNode.key, midNode.value, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -249,7 +249,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.key, midNode.val, midNode.count);
+            this.add(midNode.key, midNode.value, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -351,18 +351,18 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @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);
+    const {key, value, count, height} = destNode;
+    const tempNode = this.createNode(key, value, count);
     if (tempNode) {
       tempNode.height = height;
 
       destNode.key = srcNode.key;
-      destNode.val = srcNode.val;
+      destNode.value = srcNode.value;
       destNode.count = srcNode.count;
       destNode.height = srcNode.height;
 
       srcNode.key = tempNode.key;
-      srcNode.val = tempNode.val;
+      srcNode.value = tempNode.value;
       srcNode.count = tempNode.count;
       srcNode.height = tempNode.height;
     }