data-structure-typed 1.34.7 → 1.34.9

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
+import type {BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
 import {BinaryTreeDeletedResult, CP, DFSOrderPattern, FamilyPosition, LoopType} from '../../types';
 import {ITreeMultiset, ITreeMultisetNode} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
@@ -15,29 +15,21 @@ export class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIG
   implements ITreeMultisetNode<V, NEIGHBOR>
 {
   /**
-   * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
-   * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+   * 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
    * 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
    * 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,
+   * parameter when creating a new instance of the `BinaryTreeNode` class.
    */
-  constructor(id: BinaryTreeNodeId, val?: V, count = 1) {
-    super(id, val);
-    this._count = count;
+  constructor(key: BinaryTreeNodeKey, val?: V, count = 1) {
+    super(key, val);
+    this.count = count;
   }
 
-  private _count: number;
-
-  get count(): number {
-    return this._count;
-  }
-
-  set count(v: number) {
-    this._count = v;
-  }
+  count: number;
 }
 
 /**
@@ -54,7 +46,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * TreeMultiset.
    */
   constructor(options?: TreeMultisetOptions) {
-    super({...options});
+    super(options);
   }
 
   private _count = 0;
@@ -64,16 +56,16 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   }
 
   /**
-   * The function creates a new BSTNode with the given id, value, and count.
-   * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
+   * The function creates a new BSTNode with the given key, value, and count.
+   * @param {BinaryTreeNodeKey} 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 {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 id, value, and count (if provided).
+   * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
-  override createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N {
-    return new TreeMultisetNode(id, val, count) as N;
+  override createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N {
+    return new TreeMultisetNode(key, val, count) as N;
   }
 
   /**
@@ -84,17 +76,17 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * @returns the `destNode` after swapping its values with the `srcNode`.
    */
   override swapLocation(srcNode: N, destNode: N): N {
-    const {id, val, count, height} = destNode;
-    const tempNode = this.createNode(id, val, count);
+    const {key, val, count, height} = destNode;
+    const tempNode = this.createNode(key, val, count);
     if (tempNode) {
       tempNode.height = height;
 
-      destNode.id = srcNode.id;
+      destNode.key = srcNode.key;
       destNode.val = srcNode.val;
       destNode.count = srcNode.count;
       destNode.height = srcNode.height;
 
-      srcNode.id = tempNode.id;
+      srcNode.key = tempNode.key;
       srcNode.val = tempNode.val;
       srcNode.count = tempNode.count;
       srcNode.height = tempNode.height;
@@ -106,23 +98,22 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
    * necessary.
-   * @param {BinaryTreeNodeId | N} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N` (which
+   * @param {BinaryTreeNodeKey | N} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N` (which
    * represents a `BinaryTreeNode`).
    * @param [val] - The `val` parameter represents the value to be added to the binary tree node.
    * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
    * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
    * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
    */
-  override add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined {
-    count = count ?? 1;
+  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val'], count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
-    if (idOrNode instanceof TreeMultisetNode) {
-      newNode = this.createNode(idOrNode.id, idOrNode.val, idOrNode.count);
-    } else if (idOrNode === null) {
+    if (keyOrNode instanceof TreeMultisetNode) {
+      newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
+    } else if (keyOrNode === null) {
       newNode = null;
     } else {
-      newNode = this.createNode(idOrNode, val, count);
+      newNode = this.createNode(keyOrNode, val, count);
     }
     if (!this.root) {
       this._setRoot(newNode);
@@ -135,13 +126,13 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
       while (traversing) {
         if (cur) {
           if (newNode) {
-            if (this._compare(cur.id, newNode.id) === CP.eq) {
+            if (this._compare(cur.key, newNode.key) === CP.eq) {
               cur.val = newNode.val;
               cur.count += newNode.count;
               this._setCount(this.count + newNode.count);
               traversing = false;
               inserted = cur;
-            } else if (this._compare(cur.id, newNode.id) === CP.gt) {
+            } else if (this._compare(cur.key, newNode.key) === CP.gt) {
               // Traverse left of the node
               if (cur.left === undefined) {
                 //Add to the left of the current node
@@ -155,7 +146,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
                 //Traverse the left of the current node
                 if (cur.left) cur = cur.left;
               }
-            } else if (this._compare(cur.id, newNode.id) === CP.lt) {
+            } else if (this._compare(cur.key, newNode.key) === CP.lt) {
               // Traverse right of the node
               if (cur.right === undefined) {
                 //Add to the right of the current node
@@ -219,33 +210,33 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The `addMany` function takes an array of node IDs or nodes and adds them to the tree multiset, returning an array of
    * the inserted nodes.
-   * @param {(BinaryTreeNodeId | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeId or BinaryTreeNode
+   * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} keysOrNodes - An array of BinaryTreeNodeKey or BinaryTreeNode
    * objects, or null values.
    * @param {N['val'][]} [data] - The `data` parameter is an optional array of values (`N['val'][]`) that corresponds to
-   * the nodes being added. It is used when adding nodes using the `idOrNode` and `data` arguments in the `this.add()`
+   * the nodes being added. It is used when adding nodes using the `keyOrNode` and `data` arguments in the `this.add()`
    * method. If provided, the `data` array should
    * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
    */
   override addMany(
-    idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[],
+    keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
     data?: N['val'][]
   ): (N | null | undefined)[] {
     const inserted: (N | null | undefined)[] = [];
 
-    for (let i = 0; i < idsOrNodes.length; i++) {
-      const idOrNode = idsOrNodes[i];
+    for (let i = 0; i < keysOrNodes.length; i++) {
+      const keyOrNode = keysOrNodes[i];
 
-      if (idOrNode instanceof TreeMultisetNode) {
-        inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
+      if (keyOrNode instanceof TreeMultisetNode) {
+        inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
         continue;
       }
 
-      if (idOrNode === null) {
+      if (keyOrNode === null) {
         inserted.push(this.add(NaN, null, 0));
         continue;
       }
 
-      inserted.push(this.add(idOrNode, data?.[i], 1));
+      inserted.push(this.add(keyOrNode, data?.[i], 1));
     }
     return inserted;
   }
@@ -256,7 +247,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * @returns The function `perfectlyBalance()` returns a boolean value.
    */
   override perfectlyBalance(): boolean {
-    const sorted = this.DFS('in', 'node'),
+    const sorted = this.dfs('in', 'node'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
@@ -267,7 +258,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.id, midNode.val, midNode.count);
+        this.add(midNode.key, midNode.val, midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -283,7 +274,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.id, midNode.val, midNode.count);
+            this.add(midNode.key, midNode.val, midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -296,17 +287,17 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
    * node that needs to be balanced.
-   * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
+   * @param {N | BinaryTreeNodeKey | null} nodeOrKey - The `nodeOrKey` parameter can be one of the following:
    * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
    * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
    * not be taken into account when removing it. If `ignoreCount` is set to `false
    * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
    */
-  override remove(nodeOrId: N | BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[] {
+  override remove(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount = false): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
-    const curr: N | null = this.get(nodeOrId);
+    const curr: N | null = this.get(nodeOrKey);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;
@@ -397,13 +388,13 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
    * recursively or iteratively.
-   * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-   * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree) or
+   * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+   * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
    * `null` if the subtree is empty.
    * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
    */
-  subTreeSumCount(subTreeRoot: N | BinaryTreeNodeId | null): number {
-    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'id');
+  subTreeSumCount(subTreeRoot: N | BinaryTreeNodeKey | null): number {
+    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'key');
 
     if (!subTreeRoot) return 0;
 
@@ -434,15 +425,15 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
    * the `count` property of each node.
-   * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-   * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree), a
+   * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+   * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
    * `BinaryTreeNode` object, or `null` if the subtree is empty.
    * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
    * in the subtree should be increased or decreased.
    * @returns a boolean value.
    */
-  subTreeAddCount(subTreeRoot: N | BinaryTreeNodeId | null, delta: number): boolean {
-    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'id');
+  subTreeAddCount(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number): boolean {
+    if (typeof subTreeRoot === 'number') subTreeRoot = this.get(subTreeRoot, 'key');
 
     if (!subTreeRoot) return false;
 
@@ -476,14 +467,14 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
    * using a queue.
-   * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+   * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
    * `N`. It represents the property of the nodes that you want to search for.
    * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
    * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
    * to `true`, the function will return only one node. If `onlyOne`
    * @returns an array of nodes that match the given nodeProperty.
    */
-  getNodesByCount(nodeProperty: BinaryTreeNodeId | N, onlyOne?: boolean): N[] {
+  getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne = false): N[] {
     if (!this.root) return [];
     const result: N[] = [];
 
@@ -522,10 +513,10 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The BFSCount function returns an array of counts from a breadth-first search of nodes.
    * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
-   * BFS traversal.
+   * bfs traversal.
    */
   BFSCount(): number[] {
-    const nodes = super.BFS('node');
+    const nodes = super.bfs('node');
     return nodes.map(node => node.count);
   }
 
@@ -549,56 +540,53 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
    * @returns The function `morrisCount` returns an array of numbers.
    */
-  morrisCount(pattern?: 'in' | 'pre' | 'post'): number[] {
-    pattern = pattern || 'in';
+  morrisCount(pattern: DFSOrderPattern = 'in'): number[] {
     const nodes = super.morris(pattern, 'node');
     return nodes.map(node => node.count);
   }
 
   /**
-   * The function DFSIterativeCount performs an iterative depth-first search and returns an array of node counts based on
+   * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
    * the specified traversal pattern.
    * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-   * the Depth-First Search (DFS) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-   * @returns The DFSIterativeCount function returns an array of numbers, which represents the count property of each node
-   * in the DFS traversal.
+   * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
+   * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
+   * in the dfs traversal.
    */
-  DFSIterativeCount(pattern?: 'in' | 'pre' | 'post'): number[] {
-    pattern = pattern ?? 'in';
-    const nodes = super.DFSIterative(pattern, 'node');
+  dfsCountIterative(pattern: DFSOrderPattern = 'in'): number[] {
+    const nodes = super.dfsIterative(pattern, 'node');
     return nodes.map(node => node.count);
   }
 
   /**
-   * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
+   * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
    * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-   * the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
-   * @returns The DFSCount function returns an array of numbers, specifically the count property of each node in the DFS
+   * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
+   * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
    * traversal.
    */
-  DFSCount(pattern?: DFSOrderPattern): number[] {
-    pattern = pattern ?? 'in';
-    const nodes = super.DFS(pattern, 'node');
+  dfsCount(pattern: DFSOrderPattern = 'in'): number[] {
+    const nodes = super.dfs(pattern, 'node');
     return nodes.map(node => node.count);
   }
 
   /**
    * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
    * value than a given node.
-   * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+   * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
    * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
    */
-  lesserSumCount(beginNode: N | BinaryTreeNodeId | null): number {
-    if (typeof beginNode === 'number') beginNode = this.get(beginNode, 'id');
+  lesserSumCount(beginNode: N | BinaryTreeNodeKey | null): number {
+    if (typeof beginNode === 'number') beginNode = this.get(beginNode, 'key');
     if (!beginNode) return 0;
     if (!this.root) return 0;
-    const id = beginNode.id;
+    const key = beginNode.key;
 
     let sum = 0;
 
     if (this.loopType === LoopType.RECURSIVE) {
       const _traverse = (cur: N): void => {
-        const compared = this._compare(cur.id, id);
+        const compared = this._compare(cur.key, key);
         if (compared === CP.eq) {
           if (cur.right) sum += this.subTreeSumCount(cur.right);
           return;
@@ -619,7 +607,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
       while (queue.length > 0) {
         const cur = queue.shift();
         if (cur) {
-          const compared = this._compare(cur.id, id);
+          const compared = this._compare(cur.key, key);
           if (compared === CP.eq) {
             if (cur.right) sum += this.subTreeSumCount(cur.right);
             return sum;
@@ -643,25 +631,25 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
    * greater than a given ID by a specified delta value.
-   * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be one of the following:
+   * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
    * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
    * of each node should be increased.
    * @returns a boolean value.
    */
-  allGreaterNodesAddCount(node: N | BinaryTreeNodeId | null, delta: number): boolean {
-    if (typeof node === 'number') node = this.get(node, 'id');
+  allGreaterNodesAddCount(node: N | BinaryTreeNodeKey | null, delta: number): boolean {
+    if (typeof node === 'number') node = this.get(node, 'key');
     if (!node) return false;
-    const id = node.id;
+    const key = node.key;
     if (!this.root) return false;
 
     if (this.loopType === LoopType.RECURSIVE) {
       const _traverse = (cur: N) => {
-        const compared = this._compare(cur.id, id);
+        const compared = this._compare(cur.key, key);
         if (compared === CP.gt) cur.count += delta;
 
         if (!cur.left && !cur.right) return;
-        if (cur.left && this._compare(cur.left.id, id) === CP.gt) _traverse(cur.left);
-        if (cur.right && this._compare(cur.right.id, id) === CP.gt) _traverse(cur.right);
+        if (cur.left && this._compare(cur.left.key, key) === CP.gt) _traverse(cur.left);
+        if (cur.right && this._compare(cur.right.key, key) === CP.gt) _traverse(cur.right);
       };
 
       _traverse(this.root);
@@ -671,11 +659,11 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
       while (queue.length > 0) {
         const cur = queue.shift();
         if (cur) {
-          const compared = this._compare(cur.id, id);
+          const compared = this._compare(cur.key, key);
           if (compared === CP.gt) cur.count += delta;
 
-          if (cur.left && this._compare(cur.left.id, id) === CP.gt) queue.push(cur.left);
-          if (cur.right && this._compare(cur.right.id, id) === CP.gt) queue.push(cur.right);
+          if (cur.left && this._compare(cur.left.key, key) === CP.gt) queue.push(cur.left);
+          if (cur.right && this._compare(cur.right.key, key) === CP.gt) queue.push(cur.right);
         }
       }
       return true;