data-structure-typed 1.41.1 → 1.41.3

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.1",
+  "version": "1.41.3",
   "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",
@@ -32,10 +32,12 @@
     "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:integration": "npm run update:subs && jest --config jest.integration.config.js",
+    "benchmark": "ts-node test/performance/index.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",
@@ -61,22 +63,24 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.41.0",
+    "avl-tree-typed": "^1.41.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.41.0",
-    "bst-typed": "^1.41.0",
+    "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.0",
+    "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

@@ -559,21 +559,21 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
   has<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
   has<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): boolean;
 
@@ -601,28 +601,28 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): boolean {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
+
     return this.getNodes(identifier, callback, true, beginRoot, iterationType).length > 0;
   }
 
   getNode<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
   getNode<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
   getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): N | null;
 
@@ -648,28 +648,28 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): N | null {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
+
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? null;
   }
 
   get<C extends BTNCallback<N, BTNKey>>(
     identifier: BTNKey,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N, N>>(
     identifier: N | null,
     callback?: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
   get<C extends BTNCallback<N>>(
     identifier: ReturnType<C>,
     callback: C,
-    beginRoot?: N,
+    beginRoot?: N | null,
     iterationType?: IterationType
   ): V | undefined;
 
@@ -695,8 +695,8 @@ export class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNode
     iterationType = this.iterationType
   ): V | undefined {
     if ((identifier as any) instanceof BinaryTreeNode) callback = (node => node) as C;
-    // TODO may support finding node by value equal
-    return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0].value ?? undefined;
+
+    return this.getNode(identifier, callback, beginRoot, iterationType)?.value ?? undefined;
   }
 
   /**

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

@@ -1,3 +1,11 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+
 import {RBTNColor} from '../../types';
 
 export class RBTreeNode {
@@ -16,11 +24,18 @@ export class RBTreeNode {
   }
 }
 
-export const SN = new RBTreeNode(0);
+export const NIL = new RBTreeNode(0);
 
+/**
+ * 1. Each node is either red or black.
+ * 2. The root node is always black.
+ * 3. Leaf nodes are typically NIL nodes and are considered black.
+ * 4. Red nodes must have black children.
+ * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
+ */
 export class RedBlackTree {
   constructor() {
-    this._root = SN;
+    this._root = NIL;
   }
 
   protected _root: RBTreeNode;
@@ -38,13 +53,13 @@ export class RedBlackTree {
    */
   insert(key: number): void {
     const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
-    node.left = SN;
-    node.right = SN;
+    node.left = NIL;
+    node.right = NIL;
 
     let y: RBTreeNode = null as unknown as RBTreeNode;
     let x: RBTreeNode = this.root;
 
-    while (x !== SN) {
+    while (x !== NIL) {
       y = x;
       if (node.key < x.key) {
         x = x.left;
@@ -83,9 +98,9 @@ export class RedBlackTree {
    */
   delete(key: number): void {
     const helper = (node: RBTreeNode): void => {
-      let z: RBTreeNode = SN;
+      let z: RBTreeNode = NIL;
       let x: RBTreeNode, y: RBTreeNode;
-      while (node !== SN) {
+      while (node !== NIL) {
         if (node.key === key) {
           z = node;
         }
@@ -97,16 +112,16 @@ export class RedBlackTree {
         }
       }
 
-      if (z === SN) {
+      if (z === NIL) {
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === SN) {
+      if (z.left === NIL) {
         x = z.right;
         this._rbTransplant(z, z.right);
-      } else if (z.right === SN) {
+      } else if (z.right === NIL) {
         x = z.left;
         this._rbTransplant(z, z.left);
       } else {
@@ -133,8 +148,8 @@ export class RedBlackTree {
     helper(this.root);
   }
 
-  isRealNode(node: RBTreeNode): node is RBTreeNode {
-    return node !== SN && node !== null;
+  isRealNode(node: RBTreeNode | null | undefined): node is RBTreeNode {
+    return node !== NIL && node !== null;
   }
 
   /**
@@ -170,7 +185,7 @@ export class RedBlackTree {
    * @returns The leftmost node in the given RBTreeNode.
    */
   getLeftMost(node: RBTreeNode = this.root): RBTreeNode {
-    while (node.left !== null && node.left !== SN) {
+    while (node.left !== null && node.left !== NIL) {
       node = node.left;
     }
     return node;
@@ -182,7 +197,7 @@ export class RedBlackTree {
    * @returns the rightmost node in a red-black tree.
    */
   getRightMost(node: RBTreeNode): RBTreeNode {
-    while (node.right !== null && node.right !== SN) {
+    while (node.right !== null && node.right !== NIL) {
       node = node.right;
     }
     return node;
@@ -194,12 +209,12 @@ export class RedBlackTree {
    * @returns the successor of the given RBTreeNode.
    */
   getSuccessor(x: RBTreeNode): RBTreeNode {
-    if (x.right !== SN) {
+    if (x.right !== NIL) {
       return this.getLeftMost(x.right);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== SN && y !== null && x === y.right) {
+    while (y !== NIL && y !== null && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -213,12 +228,12 @@ export class RedBlackTree {
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
   getPredecessor(x: RBTreeNode): RBTreeNode {
-    if (x.left !== SN) {
+    if (x.left !== NIL) {
       return this.getRightMost(x.left);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== SN && x === y.left) {
+    while (y !== NIL && x === y.left) {
       x = y;
       y = y.parent;
     }
@@ -226,6 +241,65 @@ export class RedBlackTree {
     return y;
   }
 
+  print(beginRoot: RBTreeNode = this.root) {
+    const display = (root: RBTreeNode | null): void => {
+      const [lines, , ,] = _displayAux(root);
+      for (const line of lines) {
+        console.log(line);
+      }
+    };
+
+    const _displayAux = (node: RBTreeNode | null): [string[], number, number, number] => {
+      if (node === null) {
+        return [[], 0, 0, 0];
+      }
+
+      if (node.right === null && node.left === null) {
+        const line = `${node.key}`;
+        const width = line.length;
+        const height = 1;
+        const middle = Math.floor(width / 2);
+        return [[line], width, height, middle];
+      }
+
+      if (node.right === null) {
+        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 (node.left === null) {
+        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);
+  }
+
   /**
    * The function performs a left rotation on a red-black tree node.
    * @param {RBTreeNode} x - The parameter `x` is a RBTreeNode object.
@@ -233,7 +307,7 @@ export class RedBlackTree {
   protected _leftRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.right;
     x.right = y.left;
-    if (y.left !== SN) {
+    if (y.left !== NIL) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -256,7 +330,7 @@ export class RedBlackTree {
   protected _rightRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.left;
     x.left = y.right;
-    if (y.right !== SN) {
+    if (y.right !== NIL) {
       y.right.parent = x;
     }
     y.parent = x.parent;

package/test/integration/avl-tree.test.ts

@@ -12,13 +12,13 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10);
-    expect(getNodeById?.key).toBe(10);
+    const getValueById = tree.get(10);
+    expect(getValueById).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
     expect(getMinNodeByRoot?.key).toBe(1);
 
-    const node15 = tree.get(15);
+    const node15 = tree.getNode(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 

package/test/integration/bst.test.ts

@@ -20,16 +20,16 @@ describe('Individual package BST operations test', () => {
     expect(node6 && bst.getHeight(6)).toBe(2);
     expect(node6 && bst.getDepth(6)).toBe(3);
 
-    const nodeId10 = bst.get(10);
+    const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.get(9, node => node.value);
+    const nodeVal9 = bst.getNode(9, node => node.value);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = bst.get(15);
+    const node15 = bst.getNode(15);
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -43,7 +43,7 @@ describe('Individual package BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = bst.get(11);
+    const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = bst.dfs(node => node, 'in');
@@ -216,7 +216,7 @@ describe('Individual package BST operations test', () => {
 
     expect(objBST.has(6)).toBe(true);
 
-    const node6 = objBST.get(6);
+    const node6 = objBST.getNode(6);
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
@@ -229,7 +229,7 @@ describe('Individual package BST operations test', () => {
     const leftMost = objBST.getLeftMost();
     expect(leftMost?.key).toBe(1);
 
-    const node15 = objBST.get(15);
+    const node15 = objBST.getNode(15);
     expect(node15?.value).toEqual({key: 15, keyA: 15});
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
@@ -244,7 +244,7 @@ describe('Individual package BST operations test', () => {
 
     expect(node15).toBeInstanceOf(BSTNode);
 
-    const node11 = objBST.get(11);
+    const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
     const dfsInorderNodes = objBST.dfs(node => node, 'in');

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

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

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

@@ -0,0 +1,20 @@
+import {Queue} from "../../../../src";
+
+import * as Benchmark from 'benchmark';
+
+export const suite = new Benchmark.Suite();
+
+suite
+  .add('push', () => {
+    const queue = new Queue<number>();
+    for (let i = 0; i < 1000000; i++) {
+      queue.push(i);
+    }
+  })
+  // .add('shift', () => {
+  //   const queue = new Queue<number>();
+  //   for (let i = 0; i < 10000; i++) {
+  //     queue.push(i);
+  //     queue.shift();
+  //   }
+  // })

package/test/performance/index.ts

@@ -0,0 +1,47 @@
+import * as Benchmark from 'benchmark';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as fastGlob from 'fast-glob';
+
+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 i = 0;
+testFiles.forEach((file: string) => {
+  i++;
+  console.log(`testing file ${file}`);
+  const testName = path.basename(file, '.test.ts');
+  const testFunction = require(file);
+  const {suite} = testFunction;
+
+  if (suite) {
+    suite.on('cycle', (event: any) => {
+      console.log(String(event.target));
+    });
+
+    suite.on('complete', function (this: Benchmark.Suite) {
+      console.log('Fastest is ' + this.filter('fastest').map('name'));
+      report[testName] = this.map((test: Benchmark) => ({
+        name: test.name,
+        periodMS: test.times.period * 1000,
+        hz: test.hz,
+        count: test.count,
+        mean: test.stats.mean,
+        deviation: test.stats.deviation,
+      }));
+      // report[testName] = this;
+      console.log('----i', i, testFiles.length)
+      if (testFiles.length === i) {
+        if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, { recursive: true });
+
+        const filePath = path.join(reportDistPath, 'report.json');
+        fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+        console.log('Performance test report file generated')
+      }
+    })
+      .run({async: true});
+  }
+});