stack-typed 1.47.6 → 1.47.7

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

@@ -5,16 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BTNKey, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
-import {
-  BiTreeDeleteResult,
-  BTNCallback,
-  CP,
-  FamilyPosition,
-  IterableEntriesOrKeys,
-  IterationType,
-  TreeMultimapNested
+import type {
+  BSTNodeKeyOrNode,
+  BTNKey,
+  BTNodeExemplar,
+  TreeMultimapNodeNested,
+  TreeMultimapOptions
 } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, FamilyPosition, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -48,21 +46,18 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   extends AVLTree<V, N, TREE>
   implements IBinaryTree<V, N, TREE> {
 
-  /**
-   * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
-   * merge duplicated values.
-   * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
-   * TreeMultimap.
-   */
-  constructor(elements?: IterableEntriesOrKeys<V>, options?: Partial<TreeMultimapOptions>) {
+  constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<TreeMultimapOptions>) {
     super([], options);
-    if (elements) this.init(elements);
+    if (elements) this.addMany(elements);
   }
 
   private _count = 0;
 
+  // TODO the _count is not accurate after nodes count modified
   get count(): number {
-    return this._count;
+    let sum = 0;
+    this.subTreeTraverse(node => sum += node.count);
+    return sum;
   }
 
   /**
@@ -85,126 +80,66 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     }) as TREE;
   }
 
+  /**
+   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add 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(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add 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 `add` function adds a new node to the tree multimap, updating the count if the key already
-   * exists, and balances the tree if necessary.
-   * @param {BTNKey | N | null | undefined} keyOrNode - The `keyOrNode` parameter can be one of the
-   * following types:
-   * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-   * being added to the tree. It is an optional parameter, so it can be omitted if not needed.
+   * The `add` function overrides the base class `add` function to add a new node to the tree multimap
+   * and update the count.
+   * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
    * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-   * times the key-value pair should be added to the multimap. If not provided, the default value is 1.
-   * @returns a node (`N`) or `undefined`.
+   * times the key or node or entry should be added to the multimap. If not provided, the default value
+   * is 1.
+   * @returns either a node (`N`) or `undefined`.
    */
-  override add(keyOrNode: BTNKey | N | null | undefined, value?: V, count = 1): N | undefined {
-    if (keyOrNode === null) return undefined;
-    let inserted: N | undefined = undefined,
-      newNode: N | undefined;
-    if (keyOrNode instanceof TreeMultimapNode) {
-      newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
-    } else if (keyOrNode === undefined) {
-      newNode = undefined;
+  override add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count = 1): N | undefined {
+    let newNode: N | undefined;
+    if (keyOrNodeOrEntry === undefined || keyOrNodeOrEntry === null) {
+      return;
+    } else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
+      newNode = keyOrNodeOrEntry;
+    } else if (this.isNodeKey(keyOrNodeOrEntry)) {
+      newNode = this.createNode(keyOrNodeOrEntry, undefined, count);
+    } else if (this.isEntry(keyOrNodeOrEntry)) {
+      const [key, value] = keyOrNodeOrEntry;
+      if (key === undefined || key === null) {
+        return;
+      } else {
+        newNode = this.createNode(key, value, count);
+      }
     } else {
-      newNode = this.createNode(keyOrNode, value, count);
+      return;
     }
-    if (!this.root) {
-      this._setRoot(newNode);
-      this._size = this.size + 1;
-      if (newNode) this._count += newNode.count;
-      inserted = this.root;
-    } else {
-      let cur = this.root;
-      let traversing = true;
-      while (traversing) {
-        if (cur) {
-          if (newNode) {
-            if (this._compare(cur.key, newNode.key) === CP.eq) {
-              cur.value = newNode.value;
-              cur.count += newNode.count;
-              this._count += newNode.count;
-              traversing = false;
-              inserted = cur;
-            } 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
-                cur.left = newNode;
-                this._size = this.size + 1;
-                this._count += newNode.count;
-
-                traversing = false;
-                inserted = cur.left;
-              } else {
-                //Traverse the left of the current node
-                if (cur.left) cur = cur.left;
-              }
-            } 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
-                cur.right = newNode;
-                this._size = this.size + 1;
-                this._count += newNode.count;
-
-                traversing = false;
-                inserted = cur.right;
-              } else {
-                //Traverse the left of the current node
-                if (cur.right) cur = cur.right;
-              }
-            }
-          } else {
-            // TODO may need to support undefined inserted
-          }
-        } else {
-          traversing = false;
-        }
-      }
+    const orgNodeCount = newNode?.count || 0;
+    const inserted = super.add(newNode);
+    if (inserted) {
+      this._count += orgNodeCount;
     }
-    if (inserted) this._balancePath(inserted);
     return inserted;
   }
 
   /**
-   * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
+   * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add 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(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.
+   * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add 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 function `addMany` takes an array of keys or nodes and adds them to the TreeMultimap,
-   * returning an array of the inserted nodes.
-   * @param {(BTNKey | N | undefined)[]} keysOrNodes - An array of keys or nodes. Each element can be
-   * of type BTNKey, N, or undefined.
-   * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond to the
-   * keys or nodes being added. It is used to associate data with each key or node being added to the
-   * TreeMultimap. If provided, the length of the `data` array should be the same as the length of the
-   * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
+   * The function overrides the addMany method to add multiple keys, nodes, or entries to a data
+   * structure.
+   * @param keysOrNodesOrEntries - The parameter `keysOrNodesOrEntries` is an iterable that can contain
+   * either keys, nodes, or entries.
+   * @returns The method is returning an array of type `N | undefined`.
    */
-  override addMany(keysOrNodes: (BTNKey | N | undefined)[], data?: V[]): (N | undefined)[] {
-    const inserted: (N | undefined)[] = [];
-
-    for (let i = 0; i < keysOrNodes.length; i++) {
-      const keyOrNode = keysOrNodes[i];
-
-      if (keyOrNode instanceof TreeMultimapNode) {
-        inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
-        continue;
-      }
-
-      if (keyOrNode === undefined) {
-        inserted.push(this.add(NaN, undefined, 0));
-        continue;
-      }
-
-      inserted.push(this.add(keyOrNode, data?.[i], 1));
-    }
-    return inserted;
+  override addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>): (N | undefined)[] {
+    return super.addMany(keysOrNodesOrEntries);
   }
 
   /**
@@ -235,7 +170,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
         const midNode = sorted[m];
-        this.add(midNode.key, midNode.value, midNode.count);
+        this.add([midNode.key, midNode.value], midNode.count);
         buildBalanceBST(l, m - 1);
         buildBalanceBST(m + 1, r);
       };
@@ -251,7 +186,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
           if (l <= r) {
             const m = l + Math.floor((r - l) / 2);
             const midNode = sorted[m];
-            this.add(midNode.key, midNode.value, midNode.count);
+            this.add([midNode.key, midNode.value], midNode.count);
             stack.push([m + 1, r]);
             stack.push([l, m - 1]);
           }
@@ -320,7 +255,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
         const leftSubTreeRightMost = curr.left ? this.getRightMost(curr.left) : undefined;
         if (leftSubTreeRightMost) {
           const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
-          orgCurrent = this._swap(curr, leftSubTreeRightMost);
+          orgCurrent = this._swapProperties(curr, leftSubTreeRightMost);
           if (parentOfLeftSubTreeMax) {
             if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
               parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
@@ -358,24 +293,6 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     this._count = 0;
   }
 
-  /**
-   * 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.
-   */
-
-  init(elements: IterableEntriesOrKeys<V>): void {
-    if (elements) {
-      for (const entryOrKey of elements) {
-        if (Array.isArray(entryOrKey)) {
-          const [key, value] = entryOrKey;
-          this.add(key, value);
-        } else {
-          this.add(entryOrKey);
-        }
-      }
-    }
-  }
-
   /**
    * 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.
@@ -391,8 +308,8 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
    * @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);
+  protected override _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<N>): N | undefined {
+    parent = this.ensureNode(parent);
     if (parent) {
       if (parent.left === undefined) {
         parent.left = newNode;
@@ -418,7 +335,7 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
   }
 
   /**
-   * The `_swap` function swaps the key, value, count, and height properties between two nodes.
+   * The `_swapProperties` 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
    * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
    * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
@@ -426,9 +343,9 @@ 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 {
-    srcNode = this.ensureNotKey(srcNode);
-    destNode = this.ensureNotKey(destNode);
+  protected override _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined {
+    srcNode = this.ensureNode(srcNode);
+    destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, height } = destNode;
       const tempNode = this.createNode(key, value, count);
@@ -450,4 +367,9 @@ export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultim
     }
     return undefined;
   }
+
+  protected _replaceNode(oldNode: N, newNode: N): N {
+    newNode.count = oldNode.count + newNode.count
+    return super._replaceNode(oldNode, newNode);
+  }
 }

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

@@ -19,20 +19,16 @@ export class HashMap<K = any, V = any> {
   protected _hashFn: (key: K) => string;
   protected _objHashFn: (key: K) => object;
 
-  /**
-   * The constructor initializes a HashMapLinkedNode with an optional iterable of key-value pairs.
-   * @param options - The `options` parameter is an object that contains the `elements` property. The
-   * `elements` property is an iterable that contains key-value pairs represented as arrays `[K, V]`.
-   */
-  constructor(options: HashMapOptions<K, V> = {
-    elements: [],
+
+  constructor(elements?: Iterable<[K, V]>, options: HashMapOptions<K> = {
+
     hashFn: (key: K) => String(key),
     objHashFn: (key: K) => (<object>key)
   }) {
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
-    const { elements, hashFn, objHashFn } = options;
+    const { hashFn, objHashFn } = options;
     this._hashFn = hashFn;
     this._objHashFn = objHashFn;
     if (elements) {
@@ -379,6 +375,10 @@ export class HashMap<K = any, V = any> {
     }
   }
 
+  print() {
+    console.log([...this]);
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

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

@@ -29,13 +29,20 @@ export class Trie {
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
     this._caseSensitive = caseSensitive;
+    this._size = 0;
     if (words) {
-      for (const i of words) {
-        this.add(i);
+      for (const word of words) {
+        this.add(word);
       }
     }
   }
 
+  protected _size: number;
+
+  get size(): number {
+    return this._size;
+  }
+
   protected _caseSensitive: boolean;
 
   get caseSensitive(): boolean {
@@ -64,6 +71,7 @@ export class Trie {
   add(word: string): boolean {
     word = this._caseProcess(word);
     let cur = this.root;
+    let isNewWord = false;
     for (const c of word) {
       let nodeC = cur.children.get(c);
       if (!nodeC) {
@@ -72,8 +80,12 @@ export class Trie {
       }
       cur = nodeC;
     }
-    cur.isEnd = true;
-    return true;
+    if (!cur.isEnd) {
+      isNewWord = true;
+      cur.isEnd = true;
+      this._size++;
+    }
+    return isNewWord;
   }
 
   /**
@@ -143,6 +155,9 @@ export class Trie {
     };
 
     dfs(this.root, 0);
+    if (isDeleted) {
+      this._size--;
+    }
     return isDeleted;
   }
 
@@ -377,6 +392,10 @@ export class Trie {
     return accumulator;
   }
 
+  print() {
+    console.log([...this]);
+  }
+
   /**
    * Time Complexity: O(M), where M is the length of the input string.
    * Space Complexity: O(1) - Constant space.

package/src/interfaces/binary-tree.ts

@@ -6,7 +6,7 @@ import {
   BiTreeDeleteResult,
   BTNCallback,
   BTNKey,
-  IterableEntriesOrKeys
+  BTNodeExemplar,
 } from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
@@ -14,9 +14,9 @@ export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTre
 
   createTree(options?: Partial<BinaryTreeOptions>): TREE;
 
-  init(elements: IterableEntriesOrKeys<V>): void;
+  add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | null | undefined;
 
-  add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
+  addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (N | null | undefined)[];
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/src/types/common.ts

@@ -24,4 +24,14 @@ export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLeng
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
 
-export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>
+export type BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
+
+export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
+
+export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>
+
+export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>
+
+export type BTNodePureKeyOrNode<N> = BTNKey | N;
+
+export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;

package/src/types/data-structures/hash/hash-map.ts

@@ -5,8 +5,7 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
-export type HashMapOptions<K, V> = {
-  elements: Iterable<[K, V]>;
+export type HashMapOptions<K> = {
   hashFn: (key: K) => string;
   objHashFn: (key: K) => object
 }