data-structure-typed 1.42.4 → 1.42.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.42.4",
+  "version": "1.42.6",
   "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/cjs/src/index.js",
   "module": "dist/mjs/src/index.js",
@@ -30,7 +30,7 @@
     "reformat:test": "npm run lint:test && npm run format:test",
     "reformat": "npm run reformat:src && npm run reformat:test",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
-    "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed queue-typed --save-dev",
+    "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "test": "jest --runInBand",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
     "benchmark": "ts-node test/performance/reportor.ts",
@@ -64,10 +64,10 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.41.8",
+    "avl-tree-typed": "^1.42.5",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.41.8",
-    "bst-typed": "^1.41.8",
+    "binary-tree-typed": "^1.42.5",
+    "bst-typed": "^1.42.5",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
@@ -75,7 +75,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.41.8",
+    "heap-typed": "^1.42.5",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
@@ -161,7 +161,9 @@
     "avl-tree",
     "tree multiset",
     "treemultiset",
-    "tree-multiset",
+    "tree multimap",
+    "treemultimap",
+    "tree-multimap",
     "binary indexed tree",
     "binaryindexedtree",
     "binary-indexed-tree",

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

@@ -4,4 +4,4 @@ export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
 export * from './rb-tree';
-export * from './tree-multiset';
+export * from './tree-multimap';

package/src/data-structures/binary-tree/{tree-multiset.ts → tree-multimap.ts}

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
+import type {BTNKey, TreeMultimapNodeNested, TreeMultimapOptions} from '../../types';
 import {BinaryTreeDeletedResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
-export class TreeMultisetNode<
+export class TreeMultimapNode<
   V = any,
-  N extends TreeMultisetNode<V, N> = TreeMultisetNodeNested<V>
+  N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>
 > extends AVLTreeNode<V, N> {
   count: number;
 
@@ -33,19 +33,19 @@ export class TreeMultisetNode<
 }
 
 /**
- * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
+export class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>>
   extends AVLTree<V, N>
   implements IBinaryTree<V, N>
 {
   /**
-   * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
+   * The constructor function for a TreeMultimap class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
-   * @param {TreeMultisetOptions} [options] - An optional object that contains additional configuration options for the
-   * TreeMultiset.
+   * @param {TreeMultimapOptions} [options] - An optional object that contains additional configuration options for the
+   * TreeMultimap.
    */
-  constructor(options?: TreeMultisetOptions) {
+  constructor(options?: TreeMultimapOptions) {
     super(options);
   }
 
@@ -65,7 +65,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
   override createNode(key: BTNKey, value?: V, count?: number): N {
-    return new TreeMultisetNode(key, value, count) as N;
+    return new TreeMultimapNode(key, value, count) as N;
   }
 
   /**
@@ -85,7 +85,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     if(keyOrNode === null) return undefined;
     let inserted: N  | undefined = undefined,
       newNode: N | undefined;
-    if (keyOrNode instanceof TreeMultisetNode) {
+    if (keyOrNode instanceof TreeMultimapNode) {
       newNode = this.createNode(keyOrNode.key, keyOrNode.value, keyOrNode.count);
     } else if (keyOrNode === undefined) {
       newNode = undefined;
@@ -184,10 +184,10 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
   }
 
   /**
-   * The `addMany` function adds multiple keys or nodes to a TreeMultiset and returns an array of the
+   * The `addMany` function adds multiple keys or nodes to a TreeMultimap and returns an array of the
    * inserted nodes.
    * @param {(BTNKey | undefined)[] | (N | undefined)[]} keysOrNodes - An array of keys or nodes to be
-   * added to the multiset. Each element can be either a BTNKey or a TreeMultisetNode.
+   * added to the multiset. Each element can be either a BTNKey or a TreeMultimapNode.
    * @param {V[]} [data] - The `data` parameter is an optional array of values that correspond
    * to the keys or nodes being added to the multiset. It is used to associate additional data with
    * each key or node.
@@ -199,7 +199,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     for (let i = 0; i < keysOrNodes.length; i++) {
       const keyOrNode = keysOrNodes[i];
 
-      if (keyOrNode instanceof TreeMultisetNode) {
+      if (keyOrNode instanceof TreeMultimapNode) {
         inserted.push(this.add(keyOrNode.key, keyOrNode.value, keyOrNode.count));
         continue;
       }

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

@@ -2,5 +2,5 @@ export * from './binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';
-export * from './tree-multiset';
+export * from './tree-multimap';
 export * from './rb-tree';

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

@@ -0,0 +1,6 @@
+import {TreeMultimapNode} from '../../../data-structures';
+import {AVLTreeOptions} from './avl-tree';
+
+export type TreeMultimapNodeNested<T> = TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, TreeMultimapNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultimapOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {}

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -14,12 +14,12 @@ suite
       rbTree.add(arr[i]);
     }
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & 1000 delete randomly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
     rbTree.clear();
     for (let i = 0; i < arr.length; i++) {
       rbTree.add(arr[i]);
     }
-    for (let i = 0; i < 1000; i++) {
+    for (let i = 0; i < arr.length; i++) {
       rbTree.delete(arr[i]);
     }
   })

package/test/performance/reportor.ts

@@ -100,8 +100,8 @@ const composeReport = () => {
                     </body>
                   </html>`;
   replaceMarkdownContent(
-    '[//]: # (Start of Replace Section)', // Start tag
-    '[//]: # (End of Replace Section)', // end identifier
+    '[//]: # (No deletion!!! Start of Replace Section)', // Start tag
+    '[//]: # (No deletion!!! End of Replace Section)', // end identifier
     htmlTables // New content to be inserted
   );
   fs.writeFileSync(htmlFilePath, html);