data-structure-typed 1.52.9 → 1.53.1

package/benchmark/report.json

@@ -1,415 +1,55 @@
 {
-  "heap": {
-    "benchmarks": [
-      {
-        "test name": "100,000 add",
-        "time taken (ms)": "6.66",
-        "executions per sec": "150.18",
-        "sample deviation": "2.19e-4"
-      },
-      {
-        "test name": "100,000 add & poll",
-        "time taken (ms)": "35.35",
-        "executions per sec": "28.29",
-        "sample deviation": "8.55e-4"
-      }
-    ],
-    "testName": "heap"
-  },
   "rb-tree": {
     "benchmarks": [
       {
         "test name": "100,000 add",
-        "time taken (ms)": "83.70",
-        "executions per sec": "11.95",
-        "sample deviation": "4.47e-4"
-      },
-      {
-        "test name": "100,000 add randomly",
-        "time taken (ms)": "85.05",
+        "time taken (ms)": "85.02",
         "executions per sec": "11.76",
-        "sample deviation": "0.00"
+        "sample deviation": "5.42e-4"
       },
       {
-        "test name": "100,000 get",
-        "time taken (ms)": "112.86",
-        "executions per sec": "8.86",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "100,000 iterator",
-        "time taken (ms)": "23.62",
-        "executions per sec": "42.34",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "100,000 add & delete orderly",
-        "time taken (ms)": "153.38",
-        "executions per sec": "6.52",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "100,000 add & delete randomly",
-        "time taken (ms)": "232.75",
-        "executions per sec": "4.30",
-        "sample deviation": "0.00"
-      }
-    ],
-    "testName": "rb-tree"
-  },
-  "queue": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 push",
-        "time taken (ms)": "46.18",
-        "executions per sec": "21.65",
+        "test name": "100,000 add randomly",
+        "time taken (ms)": "101.88",
+        "executions per sec": "9.82",
         "sample deviation": "0.01"
       },
       {
-        "test name": "100,000 push & shift",
-        "time taken (ms)": "5.40",
-        "executions per sec": "185.33",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "Native JS Array 100,000 push & shift",
-        "time taken (ms)": "2273.18",
-        "executions per sec": "0.44",
-        "sample deviation": "0.20"
-      }
-    ],
-    "testName": "queue"
-  },
-  "deque": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 push",
-        "time taken (ms)": "20.33",
-        "executions per sec": "49.20",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "1,000,000 push & pop",
-        "time taken (ms)": "26.35",
-        "executions per sec": "37.95",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "1,000,000 push & shift",
-        "time taken (ms)": "28.83",
-        "executions per sec": "34.68",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "100,000 push & shift",
-        "time taken (ms)": "2.55",
-        "executions per sec": "392.71",
-        "sample deviation": "3.48e-4"
-      },
-      {
-        "test name": "Native JS Array 100,000 push & shift",
-        "time taken (ms)": "2285.23",
-        "executions per sec": "0.44",
-        "sample deviation": "0.25"
-      },
-      {
-        "test name": "100,000 unshift & shift",
-        "time taken (ms)": "2.53",
-        "executions per sec": "395.88",
-        "sample deviation": "4.03e-4"
-      },
-      {
-        "test name": "Native JS Array 100,000 unshift & shift",
-        "time taken (ms)": "4063.57",
-        "executions per sec": "0.25",
-        "sample deviation": "0.22"
-      }
-    ],
-    "testName": "deque"
-  },
-  "hash-map": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 set",
-        "time taken (ms)": "210.30",
-        "executions per sec": "4.76",
-        "sample deviation": "0.03"
-      },
-      {
-        "test name": "Native JS Map 1,000,000 set",
-        "time taken (ms)": "217.28",
-        "executions per sec": "4.60",
-        "sample deviation": "0.03"
-      },
-      {
-        "test name": "Native JS Set 1,000,000 add",
-        "time taken (ms)": "175.11",
-        "executions per sec": "5.71",
-        "sample deviation": "0.02"
-      },
-      {
-        "test name": "1,000,000 set & get",
-        "time taken (ms)": "231.89",
-        "executions per sec": "4.31",
-        "sample deviation": "0.05"
-      },
-      {
-        "test name": "Native JS Map 1,000,000 set & get",
-        "time taken (ms)": "278.86",
-        "executions per sec": "3.59",
-        "sample deviation": "0.03"
+        "test name": "100,000 get",
+        "time taken (ms)": "1.08",
+        "executions per sec": "921.67",
+        "sample deviation": "7.93e-5"
       },
       {
-        "test name": "Native JS Set 1,000,000 add & has",
-        "time taken (ms)": "237.24",
-        "executions per sec": "4.22",
+        "test name": "100,000 node mode add randomly",
+        "time taken (ms)": "107.93",
+        "executions per sec": "9.27",
         "sample deviation": "0.01"
       },
       {
-        "test name": "1,000,000 ObjKey set & get",
-        "time taken (ms)": "387.96",
-        "executions per sec": "2.58",
-        "sample deviation": "0.07"
-      },
-      {
-        "test name": "Native JS Map 1,000,000 ObjKey set & get",
-        "time taken (ms)": "348.73",
-        "executions per sec": "2.87",
-        "sample deviation": "0.07"
-      },
-      {
-        "test name": "Native JS Set 1,000,000 ObjKey add & has",
-        "time taken (ms)": "295.33",
-        "executions per sec": "3.39",
-        "sample deviation": "0.04"
-      }
-    ],
-    "testName": "hash-map"
-  },
-  "trie": {
-    "benchmarks": [
-      {
-        "test name": "100,000 push",
-        "time taken (ms)": "43.24",
-        "executions per sec": "23.13",
-        "sample deviation": "6.15e-4"
-      },
-      {
-        "test name": "100,000 getWords",
-        "time taken (ms)": "105.06",
-        "executions per sec": "9.52",
-        "sample deviation": "0.01"
-      }
-    ],
-    "testName": "trie"
-  },
-  "avl-tree": {
-    "benchmarks": [
-      {
-        "test name": "100,000 add",
-        "time taken (ms)": "309.91",
-        "executions per sec": "3.23",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "100,000 add randomly",
-        "time taken (ms)": "368.42",
-        "executions per sec": "2.71",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "100,000 get",
-        "time taken (ms)": "171.25",
-        "executions per sec": "5.84",
-        "sample deviation": "0.00"
+        "test name": "100,000 node mode get",
+        "time taken (ms)": "2.80",
+        "executions per sec": "357.71",
+        "sample deviation": "1.91e-4"
       },
       {
         "test name": "100,000 iterator",
-        "time taken (ms)": "26.14",
-        "executions per sec": "38.25",
-        "sample deviation": "0.00"
+        "time taken (ms)": "36.99",
+        "executions per sec": "27.04",
+        "sample deviation": "0.01"
       },
       {
         "test name": "100,000 add & delete orderly",
-        "time taken (ms)": "511.40",
-        "executions per sec": "1.96",
+        "time taken (ms)": "158.77",
+        "executions per sec": "6.30",
         "sample deviation": "0.00"
       },
       {
         "test name": "100,000 add & delete randomly",
-        "time taken (ms)": "687.43",
-        "executions per sec": "1.45",
-        "sample deviation": "0.02"
-      }
-    ],
-    "testName": "avl-tree"
-  },
-  "binary-tree-overall": {
-    "benchmarks": [
-      {
-        "test name": "10,000 RBTree add randomly",
-        "time taken (ms)": "7.30",
-        "executions per sec": "136.94",
-        "sample deviation": "9.11e-5"
-      },
-      {
-        "test name": "10,000 RBTree get randomly",
-        "time taken (ms)": "12.92",
-        "executions per sec": "77.41",
-        "sample deviation": "1.62e-4"
-      },
-      {
-        "test name": "10,000 RBTree add & delete randomly",
-        "time taken (ms)": "22.42",
-        "executions per sec": "44.60",
-        "sample deviation": "3.28e-4"
-      },
-      {
-        "test name": "10,000 AVLTree add randomly",
-        "time taken (ms)": "28.34",
-        "executions per sec": "35.29",
-        "sample deviation": "3.30e-4"
-      },
-      {
-        "test name": "10,000 AVLTree get randomly",
-        "time taken (ms)": "12.94",
-        "executions per sec": "77.27",
-        "sample deviation": "8.60e-5"
-      },
-      {
-        "test name": "10,000 AVLTree add & delete randomly",
-        "time taken (ms)": "52.35",
-        "executions per sec": "19.10",
-        "sample deviation": "5.13e-4"
-      }
-    ],
-    "testName": "binary-tree-overall"
-  },
-  "directed-graph": {
-    "benchmarks": [
-      {
-        "test name": "1,000 addVertex",
-        "time taken (ms)": "0.09",
-        "executions per sec": "1.07e+4",
-        "sample deviation": "8.73e-7"
-      },
-      {
-        "test name": "1,000 addEdge",
-        "time taken (ms)": "5.98",
-        "executions per sec": "167.36",
-        "sample deviation": "1.15e-4"
-      },
-      {
-        "test name": "1,000 getVertex",
-        "time taken (ms)": "0.09",
-        "executions per sec": "1.05e+4",
-        "sample deviation": "8.10e-7"
-      },
-      {
-        "test name": "1,000 getEdge",
-        "time taken (ms)": "23.42",
-        "executions per sec": "42.69",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "tarjan",
-        "time taken (ms)": "210.66",
-        "executions per sec": "4.75",
-        "sample deviation": "0.04"
-      },
-      {
-        "test name": "topologicalSort",
-        "time taken (ms)": "152.36",
-        "executions per sec": "6.56",
-        "sample deviation": "0.01"
-      }
-    ],
-    "testName": "directed-graph"
-  },
-  "doubly-linked-list": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 push",
-        "time taken (ms)": "196.74",
-        "executions per sec": "5.08",
-        "sample deviation": "0.04"
-      },
-      {
-        "test name": "1,000,000 unshift",
-        "time taken (ms)": "172.87",
-        "executions per sec": "5.78",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "1,000,000 unshift & shift",
-        "time taken (ms)": "151.32",
-        "executions per sec": "6.61",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "1,000,000 addBefore",
-        "time taken (ms)": "262.75",
-        "executions per sec": "3.81",
-        "sample deviation": "0.07"
-      }
-    ],
-    "testName": "doubly-linked-list"
-  },
-  "singly-linked-list": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 push & shift",
-        "time taken (ms)": "164.52",
-        "executions per sec": "6.08",
-        "sample deviation": "0.03"
-      },
-      {
-        "test name": "10,000 push & pop",
-        "time taken (ms)": "234.45",
-        "executions per sec": "4.27",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "10,000 addBefore",
-        "time taken (ms)": "275.79",
-        "executions per sec": "3.63",
-        "sample deviation": "0.00"
-      }
-    ],
-    "testName": "singly-linked-list"
-  },
-  "priority-queue": {
-    "benchmarks": [
-      {
-        "test name": "100,000 add",
-        "time taken (ms)": "30.74",
-        "executions per sec": "32.53",
-        "sample deviation": "0.00"
-      },
-      {
-        "test name": "100,000 add & poll",
-        "time taken (ms)": "88.16",
-        "executions per sec": "11.34",
-        "sample deviation": "4.14e-4"
-      }
-    ],
-    "testName": "priority-queue"
-  },
-  "stack": {
-    "benchmarks": [
-      {
-        "test name": "1,000,000 push",
-        "time taken (ms)": "42.80",
-        "executions per sec": "23.37",
-        "sample deviation": "0.01"
-      },
-      {
-        "test name": "1,000,000 push & pop",
-        "time taken (ms)": "48.13",
-        "executions per sec": "20.78",
+        "time taken (ms)": "264.70",
+        "executions per sec": "3.78",
         "sample deviation": "0.01"
       }
     ],
-    "testName": "stack"
+    "testName": "rb-tree"
   }
 }

package/dist/cjs/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNKeyOrNodeOrEntry, IterationType, BTNEntry } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNOptKeyOrNode, BTNRep, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -36,16 +36,16 @@ export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeM
 /**
  * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMapNested<K, V, R, NODE>>> extends AVLTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
+export declare class AVLTreeMultiMap<K = any, V = any, R = object, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>, TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<K, V, R, NODE, AVLTreeMultiMapNested<K, V, R, NODE>>> extends AVLTree<K, V, R, NODE, TREE> implements IBinaryTree<K, V, R, NODE, TREE> {
     /**
      * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
-     * @param keysOrNodesOrEntriesOrRaws - The `keysOrNodesOrEntriesOrRaws` parameter is an
+     * @param keysNodesEntriesOrRaws - The `keysNodesEntriesOrRaws` parameter is an
      * iterable object that can contain either keys, nodes, entries, or raw elements.
      * @param [options] - The `options` parameter is an optional object that can be used to customize the
      * behavior of the AVLTreeMultiMap. It can include properties such as `compareKeys` and
      * `compareValues` functions to define custom comparison logic for keys and values, respectively.
      */
-    constructor(keysOrNodesOrEntriesOrRaws?: Iterable<R | BTNKeyOrNodeOrEntry<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K, V, R>);
+    constructor(keysNodesEntriesOrRaws?: Iterable<R | BTNRep<K, V, NODE>>, options?: AVLTreeMultiMapOptions<K, V, R>);
     protected _count: number;
     /**
      * The function calculates the sum of the count property of all nodes in a tree using depth-first
@@ -84,17 +84,17 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
     createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE;
     /**
      * The function checks if the input is an instance of AVLTreeMultiMapNode.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The parameter
-     * `keyOrNodeOrEntryOrRaw` can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
-     * @returns a boolean value indicating whether the input parameter `keyOrNodeOrEntryOrRaw` is
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The parameter
+     * `keyNodeEntryOrRaw` can be of type `R` or `BTNRep<K, V, NODE>`.
+     * @returns a boolean value indicating whether the input parameter `keyNodeEntryOrRaw` is
      * an instance of the `AVLTreeMultiMapNode` class.
      */
-    isNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R): keyOrNodeOrEntryOrRaw is NODE;
+    isNode(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R): keyNodeEntryOrRaw is NODE;
     /**
-     * The function `keyValueOrEntryOrRawElementToNode` converts a key, value, entry, or raw element into
+     * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
      * a node object.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can be of type `R` or `BTNKeyOrNodeOrEntry<K, V, NODE>`.
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
      * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
      * `override` function. It represents the value associated with the key in the data structure. If no
      * value is provided, it will default to `undefined`.
@@ -102,16 +102,16 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
      * @returns either a NODE object or undefined.
      */
-    keyValueOrEntryOrRawElementToNode(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): NODE | undefined;
+    keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): [NODE | undefined, V | undefined];
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the add method of a TypeScript class to add a new node to a data structure
      * and update the count.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The
-     * `keyOrNodeOrEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
-     * can also accept a value of type `BTNKeyOrNodeOrEntry<K, V, NODE>`, which represents a key, node,
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+     * `keyNodeEntryOrRaw` parameter can accept a value of type `R`, which can be any type. It
+     * can also accept a value of type `BTNRep<K, V, NODE>`, which represents a key, node,
      * entry, or raw element
      * @param {V} [value] - The `value` parameter represents the value associated with the key in the
      * data structure. It is an optional parameter, so it can be omitted if not needed.
@@ -120,14 +120,14 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * be added once. However, you can specify a different value for `count` if you want to add
      * @returns a boolean value.
      */
-    add(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, value?: V, count?: number): boolean;
+    add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count?: number): boolean;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
      * The function overrides the delete method in a binary tree data structure, handling deletion of
      * nodes and maintaining balance in the tree.
-     * @param {BTNKeyOrNodeOrEntry<K, V, NODE> | R} keyOrNodeOrEntryOrRaw - The `predicate`
+     * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The `predicate`
      * parameter in the `delete` method is used to specify the condition for deleting a node from the
      * binary tree. It can be a key, node, or entry that determines which
      * node(s) should be deleted.
@@ -140,7 +140,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      * method returns an array of `BinaryTreeDeleteResult` objects, each containing information about the
      * deleted node and whether balancing is needed in the tree.
      */
-    delete(keyOrNodeOrEntryOrRaw: BTNKeyOrNodeOrEntry<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
+    delete(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, ignoreCount?: boolean): BinaryTreeDeleteResult<NODE>[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -176,14 +176,14 @@ export declare class AVLTreeMultiMap<K = any, V = any, R = BTNEntry<K, V>, NODE
      *
      * The `_swapProperties` function swaps the properties (key, value, count, height) between two nodes
      * in a binary search tree.
-     * @param {R | BSTNKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} srcNode - The `srcNode` parameter represents the source node
      * that will be swapped with the `destNode`.
-     * @param {R | BSTNKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
+     * @param {R | BSTNOptKeyOrNode<K, NODE>} destNode - The `destNode` parameter represents the destination
      * node where the properties will be swapped with the source node.
      * @returns The method is returning the `destNode` after swapping its properties with the `srcNode`.
      * If either `srcNode` or `destNode` is undefined, it returns `undefined`.
      */
-    protected _swapProperties(srcNode: R | BSTNKeyOrNode<K, NODE>, destNode: R | BSTNKeyOrNode<K, NODE>): NODE | undefined;
+    protected _swapProperties(srcNode: R | BSTNOptKeyOrNode<K, NODE>, destNode: R | BSTNOptKeyOrNode<K, NODE>): NODE | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)