data-structure-typed 1.46.4 → 1.46.6

package/benchmark/report.json

@@ -1,19 +1,442 @@
 {
+  "avl-tree": {
+    "benchmarks": [
+      {
+        "test name": "10,000 add randomly",
+        "time taken (ms)": "31.32",
+        "executions per sec": "31.93",
+        "sample deviation": "3.67e-4"
+      },
+      {
+        "test name": "10,000 add & delete randomly",
+        "time taken (ms)": "70.90",
+        "executions per sec": "14.10",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "10,000 addMany",
+        "time taken (ms)": "40.58",
+        "executions per sec": "24.64",
+        "sample deviation": "4.87e-4"
+      },
+      {
+        "test name": "10,000 get",
+        "time taken (ms)": "27.31",
+        "executions per sec": "36.62",
+        "sample deviation": "2.00e-4"
+      }
+    ],
+    "testName": "avl-tree"
+  },
+  "binary-tree": {
+    "benchmarks": [
+      {
+        "test name": "1,000 add randomly",
+        "time taken (ms)": "12.35",
+        "executions per sec": "80.99",
+        "sample deviation": "7.17e-5"
+      },
+      {
+        "test name": "1,000 add & delete randomly",
+        "time taken (ms)": "15.98",
+        "executions per sec": "62.58",
+        "sample deviation": "7.98e-4"
+      },
+      {
+        "test name": "1,000 addMany",
+        "time taken (ms)": "10.96",
+        "executions per sec": "91.27",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000 get",
+        "time taken (ms)": "18.61",
+        "executions per sec": "53.73",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000 dfs",
+        "time taken (ms)": "164.20",
+        "executions per sec": "6.09",
+        "sample deviation": "0.04"
+      },
+      {
+        "test name": "1,000 bfs",
+        "time taken (ms)": "58.84",
+        "executions per sec": "17.00",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "1,000 morris",
+        "time taken (ms)": "256.66",
+        "executions per sec": "3.90",
+        "sample deviation": "7.70e-4"
+      }
+    ],
+    "testName": "binary-tree"
+  },
+  "bst": {
+    "benchmarks": [
+      {
+        "test name": "10,000 add randomly",
+        "time taken (ms)": "31.59",
+        "executions per sec": "31.66",
+        "sample deviation": "2.74e-4"
+      },
+      {
+        "test name": "10,000 add & delete randomly",
+        "time taken (ms)": "74.56",
+        "executions per sec": "13.41",
+        "sample deviation": "8.32e-4"
+      },
+      {
+        "test name": "10,000 addMany",
+        "time taken (ms)": "29.16",
+        "executions per sec": "34.30",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "10,000 get",
+        "time taken (ms)": "29.24",
+        "executions per sec": "34.21",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "bst"
+  },
+  "rb-tree": {
+    "benchmarks": [
+      {
+        "test name": "100,000 add",
+        "time taken (ms)": "85.85",
+        "executions per sec": "11.65",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 add & delete randomly",
+        "time taken (ms)": "211.54",
+        "executions per sec": "4.73",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 getNode",
+        "time taken (ms)": "37.92",
+        "executions per sec": "26.37",
+        "sample deviation": "1.65e-4"
+      }
+    ],
+    "testName": "rb-tree"
+  },
+  "comparison": {
+    "benchmarks": [
+      {
+        "test name": "SRC PQ 10,000 add",
+        "time taken (ms)": "0.57",
+        "executions per sec": "1748.73",
+        "sample deviation": "4.96e-6"
+      },
+      {
+        "test name": "CJS PQ 10,000 add",
+        "time taken (ms)": "0.57",
+        "executions per sec": "1746.69",
+        "sample deviation": "4.91e-6"
+      },
+      {
+        "test name": "MJS PQ 10,000 add",
+        "time taken (ms)": "0.57",
+        "executions per sec": "1749.68",
+        "sample deviation": "4.43e-6"
+      },
+      {
+        "test name": "SRC PQ 10,000 add & pop",
+        "time taken (ms)": "3.47",
+        "executions per sec": "288.14",
+        "sample deviation": "6.38e-4"
+      },
+      {
+        "test name": "CJS PQ 10,000 add & pop",
+        "time taken (ms)": "3.39",
+        "executions per sec": "295.36",
+        "sample deviation": "3.90e-5"
+      },
+      {
+        "test name": "MJS PQ 10,000 add & pop",
+        "time taken (ms)": "3.37",
+        "executions per sec": "297.17",
+        "sample deviation": "3.03e-5"
+      }
+    ],
+    "testName": "comparison"
+  },
+  "directed-graph": {
+    "benchmarks": [
+      {
+        "test name": "1,000 addVertex",
+        "time taken (ms)": "0.10",
+        "executions per sec": "9534.93",
+        "sample deviation": "8.72e-7"
+      },
+      {
+        "test name": "1,000 addEdge",
+        "time taken (ms)": "6.30",
+        "executions per sec": "158.67",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000 getVertex",
+        "time taken (ms)": "0.05",
+        "executions per sec": "2.16e+4",
+        "sample deviation": "3.03e-7"
+      },
+      {
+        "test name": "1,000 getEdge",
+        "time taken (ms)": "22.31",
+        "executions per sec": "44.82",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "tarjan",
+        "time taken (ms)": "210.90",
+        "executions per sec": "4.74",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "tarjan all",
+        "time taken (ms)": "214.72",
+        "executions per sec": "4.66",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "topologicalSort",
+        "time taken (ms)": "172.52",
+        "executions per sec": "5.80",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "directed-graph"
+  },
   "hash-map": {
     "benchmarks": [
       {
         "test name": "1,000,000 set",
-        "time taken (ms)": "217.67",
-        "executions per sec": "4.59",
+        "time taken (ms)": "275.88",
+        "executions per sec": "3.62",
+        "sample deviation": "0.12"
+      },
+      {
+        "test name": "1,000,000 Map set",
+        "time taken (ms)": "211.66",
+        "executions per sec": "4.72",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "1,000,000 Set add",
+        "time taken (ms)": "177.72",
+        "executions per sec": "5.63",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "1,000,000 set & get",
+        "time taken (ms)": "317.60",
+        "executions per sec": "3.15",
         "sample deviation": "0.02"
       },
       {
-        "test name": "1,000,000 CPT set",
-        "time taken (ms)": "176.11",
-        "executions per sec": "5.68",
+        "test name": "1,000,000 Map set & get",
+        "time taken (ms)": "274.99",
+        "executions per sec": "3.64",
         "sample deviation": "0.03"
+      },
+      {
+        "test name": "1,000,000 Set add & has",
+        "time taken (ms)": "172.23",
+        "executions per sec": "5.81",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "1,000,000 ObjKey set & get",
+        "time taken (ms)": "929.40",
+        "executions per sec": "1.08",
+        "sample deviation": "0.07"
+      },
+      {
+        "test name": "1,000,000 Map ObjKey set & get",
+        "time taken (ms)": "310.02",
+        "executions per sec": "3.23",
+        "sample deviation": "0.05"
+      },
+      {
+        "test name": "1,000,000 Set ObjKey add & has",
+        "time taken (ms)": "283.28",
+        "executions per sec": "3.53",
+        "sample deviation": "0.04"
       }
     ],
     "testName": "hash-map"
+  },
+  "heap": {
+    "benchmarks": [
+      {
+        "test name": "10,000 add & pop",
+        "time taken (ms)": "5.80",
+        "executions per sec": "172.35",
+        "sample deviation": "8.78e-5"
+      },
+      {
+        "test name": "10,000 fib add & pop",
+        "time taken (ms)": "357.92",
+        "executions per sec": "2.79",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "heap"
+  },
+  "doubly-linked-list": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "221.57",
+        "executions per sec": "4.51",
+        "sample deviation": "0.03"
+      },
+      {
+        "test name": "1,000,000 unshift",
+        "time taken (ms)": "229.02",
+        "executions per sec": "4.37",
+        "sample deviation": "0.07"
+      },
+      {
+        "test name": "1,000,000 unshift & shift",
+        "time taken (ms)": "169.21",
+        "executions per sec": "5.91",
+        "sample deviation": "0.02"
+      },
+      {
+        "test name": "1,000,000 insertBefore",
+        "time taken (ms)": "314.48",
+        "executions per sec": "3.18",
+        "sample deviation": "0.07"
+      }
+    ],
+    "testName": "doubly-linked-list"
+  },
+  "singly-linked-list": {
+    "benchmarks": [
+      {
+        "test name": "10,000 push & pop",
+        "time taken (ms)": "212.98",
+        "executions per sec": "4.70",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "10,000 insertBefore",
+        "time taken (ms)": "250.68",
+        "executions per sec": "3.99",
+        "sample deviation": "0.01"
+      }
+    ],
+    "testName": "singly-linked-list"
+  },
+  "max-priority-queue": {
+    "benchmarks": [
+      {
+        "test name": "10,000 refill & poll",
+        "time taken (ms)": "8.91",
+        "executions per sec": "112.29",
+        "sample deviation": "2.26e-4"
+      }
+    ],
+    "testName": "max-priority-queue"
+  },
+  "priority-queue": {
+    "benchmarks": [
+      {
+        "test name": "100,000 add & pop",
+        "time taken (ms)": "103.59",
+        "executions per sec": "9.65",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "priority-queue"
+  },
+  "deque": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "14.55",
+        "executions per sec": "68.72",
+        "sample deviation": "6.91e-4"
+      },
+      {
+        "test name": "1,000,000 push & pop",
+        "time taken (ms)": "23.40",
+        "executions per sec": "42.73",
+        "sample deviation": "5.94e-4"
+      },
+      {
+        "test name": "1,000,000 push & shift",
+        "time taken (ms)": "24.41",
+        "executions per sec": "40.97",
+        "sample deviation": "1.45e-4"
+      },
+      {
+        "test name": "1,000,000 unshift & shift",
+        "time taken (ms)": "22.56",
+        "executions per sec": "44.32",
+        "sample deviation": "1.30e-4"
+      }
+    ],
+    "testName": "deque"
+  },
+  "queue": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "39.90",
+        "executions per sec": "25.07",
+        "sample deviation": "0.01"
+      },
+      {
+        "test name": "1,000,000 push & shift",
+        "time taken (ms)": "81.79",
+        "executions per sec": "12.23",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "queue"
+  },
+  "stack": {
+    "benchmarks": [
+      {
+        "test name": "1,000,000 push",
+        "time taken (ms)": "37.60",
+        "executions per sec": "26.60",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "1,000,000 push & pop",
+        "time taken (ms)": "47.01",
+        "executions per sec": "21.27",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "stack"
+  },
+  "trie": {
+    "benchmarks": [
+      {
+        "test name": "100,000 push",
+        "time taken (ms)": "45.97",
+        "executions per sec": "21.76",
+        "sample deviation": "0.00"
+      },
+      {
+        "test name": "100,000 getWords",
+        "time taken (ms)": "66.20",
+        "executions per sec": "15.11",
+        "sample deviation": "0.00"
+      }
+    ],
+    "testName": "trie"
   }
 }

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

@@ -441,11 +441,12 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
     [Symbol.iterator](node?: N | null | undefined): Generator<BTNKey, void, undefined>;
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      */
     print(beginRoot?: BTNKey | N | null | undefined): void;
+    protected _displayAux(node: N | null | undefined): [string[], number, number, number];
     protected _defaultOneParamCallback: (node: N) => number;
     /**
      * Swap the data of two nodes in the binary tree.

package/dist/cjs/data-structures/binary-tree/binary-tree.js

@@ -1447,7 +1447,7 @@ class BinaryTree {
     }
     /**
      * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * @param {N | null | undefined} beginRoot - The `root` parameter is of type `BTNKey | N | null |
      * undefined`. It represents the root node of a binary tree. The root node can have one of the
      * following types:
      */
@@ -1456,57 +1456,40 @@ class BinaryTree {
         if (!beginRoot)
             return;
         const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
+            const [lines, , ,] = this._displayAux(root);
             for (const line of lines) {
                 console.log(line);
             }
         };
-        const _displayAux = (node) => {
-            if (!this.isRealNode(node)) {
-                return [[], 0, 0, 0];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-                const line = `${node.key}`;
-                const width = line.length;
-                const height = 1;
-                const middle = Math.floor(width / 2);
-                return [[line], width, height, middle];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-                const [lines, n, p, x] = _displayAux(node.left);
-                const s = `${node.key}`;
-                const u = s.length;
-                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-                const shifted_lines = lines.map(line => line + ' '.repeat(u));
-                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-                const [lines, n, p, u] = _displayAux(node.right);
-                const s = `${node.key}`;
-                const x = s.length;
-                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-            }
-            const [left, n, p, x] = _displayAux(node.left);
-            const [right, m, q, y] = _displayAux(node.right);
-            const s = `${node.key}`;
-            const u = s.length;
-            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-            if (p < q) {
-                left.push(...new Array(q - p).fill(' '.repeat(n)));
-            }
-            else if (q < p) {
-                right.push(...new Array(p - q).fill(' '.repeat(m)));
-            }
-            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-        };
         display(beginRoot);
     }
+    _displayAux(node) {
+        if (!node) {
+            return [['─'], 1, 0, 0];
+        }
+        const line = node.key.toString();
+        const width = line.length;
+        if (!node.left && !node.right) {
+            return [[line], width, 1, Math.floor(width / 2)];
+        }
+        const [leftLines, leftWidth, leftHeight, leftMiddle] = node.left ? this._displayAux(node.left) : [[''], 0, 0, 0];
+        const [rightLines, rightWidth, rightHeight, rightMiddle] = node.right ? this._displayAux(node.right) : [[''], 0, 0, 0];
+        const firstLine = ' '.repeat(Math.max(0, leftMiddle + 1))
+            + '_'.repeat(Math.max(0, leftWidth - leftMiddle - 1))
+            + line
+            + '_'.repeat(Math.max(0, rightMiddle))
+            + ' '.repeat(Math.max(0, rightWidth - rightMiddle));
+        const secondLine = (leftHeight > 0 ? ' '.repeat(leftMiddle) + '/' + ' '.repeat(leftWidth - leftMiddle - 1) : ' '.repeat(leftWidth))
+            + ' '.repeat(width)
+            + (rightHeight > 0 ? ' '.repeat(rightMiddle) + '\\' + ' '.repeat(rightWidth - rightMiddle - 1) : ' '.repeat(rightWidth));
+        const mergedLines = [firstLine, secondLine];
+        for (let i = 0; i < Math.max(leftHeight, rightHeight); i++) {
+            const leftLine = i < leftHeight ? leftLines[i] : ' '.repeat(leftWidth);
+            const rightLine = i < rightHeight ? rightLines[i] : ' '.repeat(rightWidth);
+            mergedLines.push(leftLine + ' '.repeat(width) + rightLine);
+        }
+        return [mergedLines, leftWidth + width + rightWidth, Math.max(leftHeight, rightHeight) + 2, leftWidth + Math.floor(width / 2)];
+    }
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.