data-structure-typed 1.44.0 → 1.44.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.44.0",
+  "version": "1.44.1",
   "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",
@@ -20,6 +20,7 @@
     "build:umd": "tsup",
     "build:docs": "typedoc --out docs ./src",
     "test:unit": "jest --runInBand",
+    "test": "npm run test:unit",
     "test:integration": "npm run update:subs && jest --config jest.integration.config.js",
     "test:perf": "ts-node test/performance/reportor.ts",
     "check": "tsc --noEmit",
@@ -32,7 +33,7 @@
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
     "ci": "env && git fetch --tags && npm run check && npm run lint && npm run build && npm run test:unit && npm run changelog",
-    "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
+    "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-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",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
@@ -63,10 +64,11 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.42.5",
+    "avl-tree-typed": "^1.44.0",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.42.5",
-    "bst-typed": "^1.42.5",
+    "binary-tree-typed": "^1.44.0",
+    "bst-typed": "^1.44.0",
+    "data-structure-typed": "^1.44.0",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
@@ -74,7 +76,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.42.5",
+    "heap-typed": "^1.44.0",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

package/src/types/data-structures/graph/directed-graph.ts

@@ -1,8 +1,2 @@
 // 0 means unknown, 1 means visiting, 2 means visited;
 export type TopologicalStatus = 0 | 1 | 2;
-
-export enum TopologicalProperty {
-  VAL = 'VAL',
-  NODE = 'NODE',
-  ID = 'ID'
-}

package/test/config.ts

@@ -1,2 +1,2 @@
 export const isDebugTest: boolean = false;
-export const isCompetitor: boolean = false;
+export const isCompetitor: boolean = true;

package/test/integration/all-in-one.ts

@@ -0,0 +1,110 @@
+import {AVLTree, CP} from 'data-structure-typed';
+
+describe('AVL Tree Test from data-structure-typed', () => {
+  it('should perform various operations on a AVL Tree from data-structure-typed', () => {
+    const keys = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const tree = new AVLTree();
+
+    for (const i of keys) tree.add(i, i);
+
+    const node6 = tree.get(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getValueById = tree.get(10);
+    expect(getValueById).toBe(10);
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+
+    const node15 = tree.getNode(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.value).toBe(15);
+
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});

package/test/performance/reportor.ts

@@ -107,7 +107,7 @@ const composeReport = () => {
     htmlTables // New content to be inserted
   );
   fs.writeFileSync(htmlFilePath, html);
-  console.log(`Performance ${BOLD}${GREEN}report${END} file generated`);
+  console.log(`Performance ${BOLD}${GREEN}report${END} file generated in ${BOLD}${GREEN}${reportDistPath}${END}`);
 };
 
 function replaceMarkdownContent(startMarker: string, endMarker: string, newText: string) {
@@ -135,7 +135,7 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
       if (err) {
         console.error(`Unable to write to ${filePath}:`, err);
       } else {
-        console.log(`The content has been successfully replaced in ${filePath}!`);
+        console.log(`The content has been successfully replaced in ${BOLD}${GREEN}${filePath}!${END}`);
       }
     });
   });

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

@@ -478,13 +478,13 @@ describe('RedBlackTree', () => {
     for (let i = 0; i < arr.length; i++) {
       tree.add(arr[i]);
     }
-    console.log(performance.now() - tS);
+    isDebug && console.log(performance.now() - tS);
 
     const cS = performance.now();
 
     for (let i = 0; i < arr.length; i++) {
       competitor.setElement(arr[i], arr[i]);
     }
-    console.log(performance.now() - cS);
+    isDebug && console.log(performance.now() - cS);
   });
 });