data-structure-typed 1.41.2 → 1.41.4

package/jest.integration.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['<rootDir>/test/integration/**/*.test.ts', '<rootDir>/test/integration/**/*.test.js'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.41.2",
+  "version": "1.41.4",
   "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/index.js",
   "module": "dist/mjs/index.js",
@@ -31,15 +31,17 @@
     "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",
-    "test": "jest",
+    "test": "jest --runInBand",
+    "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
+    "benchmark": "ts-node test/performance/reportor.ts",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
-    "ci": "env && git fetch --tags && npm run check && npm run lint && npm run build && npm run update:subs && npm run test && npm run changelog",
+    "ci": "env && git fetch --tags && npm run check && npm run lint && npm run build && npm run test && npm run changelog",
     "copy:to-subs": "sh scripts/copy_to_all_subs.sh",
     "publish:subs": "npm run copy:to-subs && sh scripts/publish_all_subs.sh",
     "publish:docs": "sh scripts/publish_docs.sh",
-    "publish:all": "npm run ci && npm publish && npm run publish:docs && npm run publish:subs"
+    "publish:all": "npm run ci && npm run benchmark && npm publish && npm run publish:docs && npm run publish:subs"
   },
   "repository": {
     "type": "git",
@@ -58,25 +60,28 @@
     "@types/benchmark": "^2.1.3",
     "@types/jest": "^29.5.5",
     "@types/node": "^20.8.2",
+    "@types/underscore": "^1.11.12",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.41.1",
+    "avl-tree-typed": "^1.41.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.41.1",
-    "bst-typed": "^1.41.1",
+    "binary-tree-typed": "^1.41.2",
+    "bst-typed": "^1.41.2",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.41.1",
+    "fast-glob": "^3.3.1",
+    "heap-typed": "^1.41.2",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
     "ts-jest": "^29.1.1",
     "ts-loader": "^9.4.4",
+    "ts-node": "^10.9.1",
     "tsup": "^7.2.0",
     "typedoc": "^0.25.1",
     "typescript": "^5.2.2"

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

@@ -179,7 +179,10 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       while (queue.size > 0) {
         const cur = queue.shift();
         if (cur) {
-          if (newNode && cur.key === newNode.key) return;
+          if (newNode && cur.key === newNode.key) {
+            cur.value = newNode.value;
+            return;
+          }
           const inserted = this._addTo(newNode, cur);
           if (inserted !== undefined) return inserted;
           if (cur.left) queue.push(cur.left);
@@ -201,16 +204,16 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
       return;
     }
 
-    const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
-    const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
+    // const key = typeof keyOrNode === 'number' ? keyOrNode : keyOrNode ? keyOrNode.key : undefined;
+    // const existNode = key !== undefined ? this.getNode(key, (node: N) => node.key) : undefined;
 
     if (this.root) {
-      if (existNode) {
-        existNode.value = value;
-        inserted = existNode;
-      } else {
-        inserted = _bfs(this.root, needInsert);
-      }
+      // if (existNode) {
+      //   existNode.value = value;
+      //   inserted = existNode;
+      // } else {
+      inserted = _bfs(this.root, needInsert);
+      // }
     } else {
       this._setRoot(needInsert);
       if (needInsert !== null) {

package/test/config.ts

@@ -1 +1 @@
-export const isDebugTest = true;
+export const isDebugTest = false;

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

@@ -0,0 +1,24 @@
+import {AVLTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude, randomInt, randomIntArray} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const avl = new AVLTree<number>();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`add ${N_LOG_N} randomly`, () => {
+    for (let i = 0; i < N_LOG_N; i++) avl.add(randomInt(0, N_LOG_N));
+  })
+  .add(`delete ${N_LOG_N} randomly`, () => {
+    for (let i = 0; i < N_LOG_N; i++) avl.delete(randomInt(0, N_LOG_N));
+  })
+  .add(`addMany ${N_LOG_N}`, () => {
+    const arr = randomIntArray(N_LOG_N);
+    avl.addMany(arr);
+  })
+  .add(`get ${N_LOG_N}`, () => {
+    for (let i = 0; i < N_LOG_N; i++) avl.get(randomInt(-N_LOG_N, N_LOG_N));
+  });
+
+export {suite};

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

@@ -0,0 +1,25 @@
+import {BinaryTree} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude, randomInt, randomIntArray} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const biTree = new BinaryTree<number>();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`add ${N_LOG_N}`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.add(randomInt(-N_LOG_N, N_LOG_N));
+  })
+  .add(`delete ${N_LOG_N}`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.delete(randomInt(-N_LOG_N, N_LOG_N));
+  })
+  .add(`addMany ${N_LOG_N}`, () => {
+    biTree.clear();
+    const arr = randomIntArray(N_LOG_N);
+    biTree.addMany(arr);
+  })
+  .add(`get ${N_LOG_N}`, () => {
+    for (let i = 0; i < N_LOG_N; i++) biTree.get(randomInt(-N_LOG_N, N_LOG_N));
+  });
+
+export {suite};

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

@@ -0,0 +1,24 @@
+import {BST} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude, randomInt, randomIntArray} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const bst = new BST<number>();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`add ${N_LOG_N} randomly`, () => {
+    for (let i = 0; i < N_LOG_N; i++) bst.add(randomInt(0, N_LOG_N));
+  })
+  .add(`delete ${N_LOG_N} randomly`, () => {
+    for (let i = 0; i < N_LOG_N; i++) bst.delete(randomInt(0, N_LOG_N));
+  })
+  .add(`addMany ${N_LOG_N} balanced`, () => {
+    const arr = randomIntArray(N_LOG_N);
+    bst.addMany(arr);
+  })
+  .add(`get ${N_LOG_N}`, () => {
+    for (let i = 0; i < N_LOG_N; i++) bst.get(randomInt(-N_LOG_N, N_LOG_N));
+  });
+
+export {suite};

package/test/performance/data-structures/heap/heap.test.ts

@@ -0,0 +1,30 @@
+import {FibonacciHeap, Heap} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`add & ${N_LOG_N}`, () => {
+    const heap = new Heap<number>({comparator: (a, b) => b - a});
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      heap.add(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      heap.pop();
+    }
+  })
+  .add(`fib add & pop ${N_LOG_N}`, () => {
+    const fbHeap = new FibonacciHeap<number>();
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.push(i);
+    }
+    for (let i = 1; i <= N_LOG_N; i++) {
+      fbHeap.pop();
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -0,0 +1,40 @@
+import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR, N_LOG_N} = magnitude;
+
+suite
+  .add(`unshift ${LINEAR}`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+  })
+  .add(`unshift & shift ${LINEAR}`, () => {
+    const list = new DoublyLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.unshift(i);
+    }
+    for (let i = 0; i < LINEAR; i++) {
+      list.shift();
+    }
+  })
+  .add(`insertBefore ${N_LOG_N}`, () => {
+    const doublyList = new DoublyLinkedList<number>();
+    let midNode: DoublyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      doublyList.push(i);
+      if (i === midIndex) {
+        midNode = doublyList.getNode(i);
+      } else if (i > midIndex && midNode) {
+        doublyList.insertBefore(midNode, i);
+      }
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -0,0 +1,34 @@
+import {SinglyLinkedList, SinglyLinkedListNode} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {N_LOG_N} = magnitude;
+
+suite
+  .add(`push & pop ${N_LOG_N}`, () => {
+    const list = new SinglyLinkedList<number>();
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.push(i);
+    }
+
+    for (let i = 0; i < N_LOG_N; i++) {
+      list.pop();
+    }
+  })
+  .add(`insertBefore ${N_LOG_N}`, () => {
+    const singlyList = new SinglyLinkedList<number>();
+    let midSinglyNode: SinglyLinkedListNode | null = null;
+    const midIndex = Math.floor(N_LOG_N / 2);
+    for (let i = 0; i < N_LOG_N; i++) {
+      singlyList.push(i);
+      if (i === midIndex) {
+        midSinglyNode = singlyList.getNode(i);
+      } else if (i > midIndex && midSinglyNode) {
+        singlyList.insertBefore(midSinglyNode.value, i);
+      }
+    }
+  });
+
+export {suite};

package/test/performance/data-structures/priority-queue/max-priority-queue.test.ts

@@ -0,0 +1,19 @@
+import {MaxPriorityQueue} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite.add(`refill & poll ${LINEAR}`, () => {
+  const nodes = Array.from(
+    new Set<number>(Array.from(new Array(LINEAR), () => Math.floor(Math.random() * LINEAR * 100)))
+  );
+  const maxPQ = new MaxPriorityQueue<number>();
+  maxPQ.refill(nodes);
+  while (maxPQ.size > 0) {
+    maxPQ.poll();
+  }
+});
+
+export {suite};

package/test/performance/data-structures/queue/deque.test.ts

@@ -0,0 +1,21 @@
+import {Deque} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+export const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite
+  .add(`push ${LINEAR}`, () => {
+    const deque = new Deque<number>();
+    for (let i = 0; i < LINEAR; i++) {
+      deque.push(i);
+    }
+  })
+  .add(`shift ${LINEAR}`, () => {
+    const deque = new Deque<number>();
+    for (let i = 0; i < LINEAR; i++) {
+      deque.push(i);
+      deque.shift();
+    }
+  });

package/test/performance/data-structures/queue/queue.test.ts

@@ -0,0 +1,25 @@
+import {Queue} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+
+const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite
+  .add(`push ${LINEAR}`, () => {
+    const queue = new Queue<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+    }
+  })
+  .add(`push & shift ${LINEAR}`, () => {
+    const queue = new Queue<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+      queue.shift();
+    }
+  });
+
+export {suite};

package/test/performance/reportor.ts

@@ -0,0 +1,174 @@
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fastGlob from 'fast-glob';
+import {Color, numberFix, render} from '../utils';
+import {PerformanceTest} from './types';
+
+const reportDistPath = 'benchmark';
+const testDir = path.join(__dirname, 'data-structures');
+const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
+
+const report: {[key: string]: any} = {};
+
+let testFileCount = 0,
+  completedCount = 0;
+
+const performanceTests: PerformanceTest[] = [];
+const {GREEN, BOLD, RED, END, YELLOW, CYAN, BG_YELLOW} = Color;
+
+testFiles.forEach((file: string) => {
+  testFileCount++;
+  const testName = path.basename(file, '.test.ts');
+  const testFunction = require(file);
+  const {suite} = testFunction;
+  if (suite) performanceTests.push({testName, suite, file});
+});
+
+const composeReport = () => {
+  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, {recursive: true});
+
+  const filePath = path.join(reportDistPath, 'report.json');
+  const htmlFilePath = path.join(reportDistPath, 'report.html');
+  fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+  let html = `<!DOCTYPE html>
+                        <html lang="en">
+                        <head>
+                          <meta charset="UTF-8">
+                          <title>performance of data-structure-typed</title>
+                          <style>
+                          *{
+                          box-sizing: border-box;
+                          }
+                                #json-to-html {
+                                padding: 0 10px 20px;
+                                }
+                                
+                                .json-to-html-label {
+                                    font-size: 2rem;
+                                    margin: 2rem 0 0 3px;
+                                }
+                               .content table {
+                                  width: 100%;
+                                  table-layout: fixed;
+                                  border-collapse: collapse;
+                                  margin-top: 10px;
+                                  font-size: 16px;
+                                }
+                            
+                                .content table th,
+                                .content table td {
+                                  padding: 8px 12px;
+                                  text-align: left;
+                                  border: 1px solid #ddd;
+                                }
+                            
+                                .content table th {
+                                  background-color: #f2f2f2;
+                                  font-weight: bold;
+                                }
+                            
+                                .content table tr:nth-child(odd) {
+                                  background-color: #ffffff;
+                                }
+                            </style>
+                        </head>
+                        <body>
+                        <div id="json-to-html">`;
+  let htmlTables = '';
+  for (const r in report) {
+    if (report.hasOwnProperty(r)) {
+      htmlTables += render(report[r].testName, report[r].benchmarks, {
+        plainHtml: true,
+        '<>': 'table',
+        html: [
+          {
+            '<>': 'tr',
+            html: [
+              {'<>': 'td', html: '${name}'},
+              {'<>': 'td', html: '${periodMS}'},
+              {'<>': 'td', html: '${mean}'}
+            ]
+          }
+        ]
+      });
+    }
+  }
+  html += htmlTables;
+  html += `</div>
+                    </body>
+                  </html>`;
+  writeIntoMarkdown(htmlTables);
+  fs.writeFileSync(htmlFilePath, html);
+  console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
+};
+
+function writeIntoMarkdown(html: string) {
+  const parentDirectory = path.resolve(__dirname, '../..'); // The path to the parent directory
+  const markdownFilePath = path.join(parentDirectory, 'README.md'); // Path to README.md file
+  const textToInsert = html;
+
+  // Read the original README.md file
+  fs.readFile(markdownFilePath, 'utf8', (err, data) => {
+    if (err) {
+      console.error('Unable to read README.md file：', err);
+      return;
+    }
+
+    // Find the location in the README.md file where you want to insert the text, for example under a specific tag
+    const insertMarker = '## Benchmark';
+
+    const index = data.indexOf(insertMarker);
+    if (index === -1) {
+      console.error('Unable to find insertion point');
+      return;
+    }
+
+    // insert text
+    const updatedMarkdown =
+      data.slice(0, index + insertMarker.length) + '\n' + textToInsert + data.slice(index + insertMarker.length);
+
+    // Try writing the modified content back to the README.md file
+    fs.writeFile(markdownFilePath, updatedMarkdown, 'utf8', err => {
+      if (err) {
+        console.error('Unable to write to README.md file：', err);
+      } else {
+        console.log('The text has been successfully inserted into the README.md file!');
+      }
+    });
+  });
+}
+
+performanceTests.forEach(item => {
+  const {suite, testName, file} = item;
+  console.log(`${BG_YELLOW}Running in${END}: ${CYAN}${file}${END}`);
+
+  if (suite) {
+    suite
+      .on('complete', function (this: Benchmark.Suite) {
+        completedCount++;
+        report[testName] = {};
+        report[testName].benchmarks = this.map((benchmark: Benchmark) => ({
+          'test name': benchmark.name,
+          'time taken (ms)': numberFix(benchmark.times.period * 1000, 2),
+          'executions per sec': numberFix(benchmark.hz, 2),
+          'executed times': numberFix(benchmark.count, 0),
+          'sample mean (secs)': numberFix(benchmark.stats.mean, 2),
+          'sample deviation': numberFix(benchmark.stats.deviation, 2)
+        }));
+        report[testName].testName = testName;
+        const isDone = completedCount === performanceTests.length;
+        console.log(
+          `Files: ${GREEN}${testFileCount}${END} `,
+          `Suites: ${GREEN}${performanceTests.length}${END} `,
+          `Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : RED}${
+            performanceTests.length
+          }${END}`
+        );
+        if (isDone) {
+          composeReport();
+        }
+      })
+      .run({async: false});
+  }
+});

package/test/performance/types/index.ts

@@ -0,0 +1 @@
+export * from './reportor';

package/test/performance/types/reportor.ts

@@ -0,0 +1,3 @@
+import * as Benchmark from 'benchmark';
+
+export type PerformanceTest = {testName: string; suite: Benchmark.Suite; file: string};

package/test/types/utils/index.ts

@@ -1 +1,2 @@
 export * from './big-o';
+export * from './json2html';

package/test/types/utils/json2html.ts

@@ -0,0 +1 @@
+export type Json2htmlOptions = {plainHtml?: boolean} & Partial<{[key: string]: any}>;

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

@@ -1,5 +1,5 @@
-import {RBTNColor, RBTreeNode, RedBlackTree, NIL} from '../../../../src';
-import {getRandomInt} from '../../../utils';
+import {NIL, RBTNColor, RBTreeNode, RedBlackTree} from '../../../../src';
+import {randomInt} from '../../../utils';
 import {isDebugTest} from '../../../config';
 
 const isDebug = isDebugTest;
@@ -427,9 +427,9 @@ describe('RedBlackTree', () => {
   });
 
   it('should fix the tree after insertion and deletion', () => {
-    for (let i = 0; i < 1000; i++) {
-      tree.insert(getRandomInt(-100, 1000));
-      tree.delete(getRandomInt(-100, 1000));
+    for (let i = 0; i < 100; i++) {
+      tree.insert(randomInt(-100, 1000));
+      tree.delete(randomInt(-100, 1000));
     }
   });
 });