data-structure-typed 1.45.0 → 1.45.1

package/test/performance/reportor.ts

@@ -2,8 +2,8 @@ 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';
+import { Color, numberFix, render } from '../utils';
+import { PerformanceTest } from './types';
 
 const parentDirectory = path.resolve(__dirname, '../..');
 const reportDistPath = path.join(parentDirectory, 'benchmark');
@@ -11,22 +11,22 @@ const reportDistPath = path.join(parentDirectory, 'benchmark');
 const testDir = path.join(__dirname, 'data-structures');
 const testFiles = fastGlob.sync(path.join(testDir, '**', '*.test.ts'));
 
-const report: {[key: string]: any} = {};
+const report: { [key: string]: any } = {};
 
 let completedCount = 0;
 
 const performanceTests: PerformanceTest[] = [];
-const {GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW} = Color;
+const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = Color;
 
 testFiles.forEach((file: string) => {
   const testName = path.basename(file, '.test.ts');
   const testFunction = require(file);
-  const {suite} = testFunction;
-  if (suite) performanceTests.push({testName, suite, file});
+  const { suite } = testFunction;
+  if (suite) performanceTests.push({ testName, suite, file });
 });
 
 const composeReport = () => {
-  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, {recursive: true});
+  if (!fs.existsSync(reportDistPath)) fs.mkdirSync(reportDistPath, { recursive: true });
 
   const filePath = path.join(reportDistPath, 'report.json');
   const htmlFilePath = path.join(reportDistPath, 'report.html');
@@ -85,9 +85,9 @@ const composeReport = () => {
           {
             '<>': 'tr',
             html: [
-              {'<>': 'td', html: '${name}'},
-              {'<>': 'td', html: '${periodMS}'},
-              {'<>': 'td', html: '${mean}'}
+              { '<>': 'td', html: '${name}' },
+              { '<>': 'td', html: '${periodMS}' },
+              { '<>': 'td', html: '${mean}' }
             ]
           }
         ]
@@ -142,7 +142,7 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
 }
 
 performanceTests.forEach(item => {
-  const {suite, testName, file} = item;
+  const { suite, testName, file } = item;
   const relativeFilePath = path.relative(__dirname, file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
@@ -173,13 +173,15 @@ performanceTests.forEach(item => {
         console.log(
           // `Files: ${GREEN}${testFileCount}${END} `,
           // `Suites: ${GREEN}${performanceTests.length}${END} `,
-          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${performanceTests.length}${END}`,
+          `Suites Progress: ${isDone ? GREEN : YELLOW}${completedCount}${END}/${isDone ? GREEN : YELLOW}${
+            performanceTests.length
+          }${END}`,
           `Time: ${isTimeWarn ? YELLOW : GREEN}${runTime}s${END}`
         );
         if (isDone) {
           composeReport();
         }
       })
-      .run({async: false});
+      .run({ async: false });
   }
 });

package/test/performance/types/reportor.ts

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

package/test/types/utils/json2html.ts

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

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

@@ -1,4 +1,4 @@
-import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
+import { AVLTree, AVLTreeNode, CP, IterationType } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -112,7 +112,7 @@ describe('AVL Tree Test', () => {
 describe('AVL Tree Test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>({iterationType: IterationType.RECURSIVE});
+    const tree = new AVLTree<number>({ iterationType: IterationType.RECURSIVE });
 
     for (const i of arr) tree.add(i, i);
 
@@ -228,9 +228,9 @@ describe('AVLTree APIs test', () => {
     avl.add(1);
     const node2 = new AVLTreeNode(2);
     avl.add(node2);
-    const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+    const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
     avl.add(node3);
-    avl.add(node3, {id: 3, text: 'text33'});
+    avl.add(node3, { id: 3, text: 'text33' });
 
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -277,9 +277,9 @@ describe('AVLTree', () => {
       avl.add(1);
       const node2 = new AVLTreeNode(2);
       avl.add(node2);
-      const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+      const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
       avl.add(node3);
-      avl.add(node3, {id: 3, text: 'text33'});
+      avl.add(node3, { id: 3, text: 'text33' });
 
       const bfsRes = avl.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);

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

@@ -1,4 +1,4 @@
-import {BinaryIndexedTree} from '../../../../src';
+import { BinaryIndexedTree } from '../../../../src';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -8,13 +8,13 @@ describe('BinaryIndexedTree simple', () => {
 
   beforeEach(() => {
     //Create a new BinaryIndexedTree instance before each test case
-    bit = new BinaryIndexedTree({frequency: 0, max: 10}); // Modify the value of max as needed
+    bit = new BinaryIndexedTree({ frequency: 0, max: 10 }); // Modify the value of max as needed
   });
 
   it('should initialize correctly', () => {
     expect(bit.freq).toBe(0);
     expect(bit.max).toBe(10);
-    expect(bit.freqMap).toEqual({0: 0}); // Modify the initialized record value according to the actual situation
+    expect(bit.freqMap).toEqual({ 0: 0 }); // Modify the initialized record value according to the actual situation
     // More initialization checks can be added
   });
 
@@ -54,7 +54,7 @@ describe('BinaryIndexedTree', () => {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({frequency, max});
+    bit = new BinaryIndexedTree({ frequency, max });
   });
   it('should validate the index', function () {
     expect(() => bit.readSingle(-1)).toThrow('Index out of range');
@@ -73,7 +73,7 @@ describe('BinaryIndexedTree', () => {
   it('should frequency and max', function () {
     const frequency = 200;
     const max = 1000;
-    const bit = new BinaryIndexedTree({frequency, max});
+    const bit = new BinaryIndexedTree({ frequency, max });
 
     expect(bit.freq).toBe(frequency);
     expect(bit.max).toBe(max);
@@ -123,7 +123,7 @@ describe('designated values', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({max: array.length});
+    bit = new BinaryIndexedTree({ max: array.length });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -182,7 +182,7 @@ describe('descending sequence', function () {
   let bit: BinaryIndexedTree;
 
   beforeEach(function () {
-    bit = new BinaryIndexedTree({max: array.length});
+    bit = new BinaryIndexedTree({ max: array.length });
     array.forEach((value, i) => bit.writeSingle(i, value));
   });
 
@@ -219,7 +219,7 @@ describe('descending sequence', function () {
 
 describe('BinaryIndexedTree additional tests', () => {
   it('should handle read method correctly', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(2, 10);
     bit.writeSingle(5, 20);
     bit.writeSingle(8, 30);
@@ -227,7 +227,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle consecutive operations', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(2, 10);
     bit.update(2, 5);
     expect(bit.readSingle(2)).toBe(15);
@@ -237,7 +237,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle frequent increment updates', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     for (let i = 0; i < 10; i++) {
       bit.update(2, 5);
     }
@@ -245,7 +245,7 @@ describe('BinaryIndexedTree additional tests', () => {
   });
 
   it('should handle edge cases', () => {
-    const bit = new BinaryIndexedTree({max: 10});
+    const bit = new BinaryIndexedTree({ max: 10 });
     bit.writeSingle(9, 100);
     expect(bit.readSingle(9)).toBe(100);
     expect(bit.lowerBound(200)).toBe(10);
@@ -291,7 +291,7 @@ describe('', () => {
 
     constructor(nums: number[]) {
       this._nums = nums;
-      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      this._tree = new BinaryIndexedTree({ max: nums.length + 1 });
       for (let i = 0; i < nums.length; i++) {
         this._tree.update(i + 1, nums[i]);
       }

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

@@ -1,6 +1,6 @@
-import {BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
-import {getRandomIntArray} from '../../../utils';
-import {FamilyPosition} from 'binary-tree-typed';
+import { BinaryTree, BinaryTreeNode, IterationType } from '../../../../src';
+import { getRandomIntArray } from '../../../utils';
+import { FamilyPosition } from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -242,8 +242,12 @@ describe('BinaryTree', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-    expect(tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([6, 3, 7, null]);
-    expect(tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
+    ).toEqual([6, 3, 7, null]);
+    expect(
+      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
+    ).toEqual([6, 3, 7, null]);
   });
 
   it('should clear the tree', () => {
@@ -315,81 +319,41 @@ describe('BinaryTree traversals', () => {
 
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
-  expect(tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    40,
-    15,
-    29,
-    null,
-    50,
-    null,
-    16,
-    28,
-    30,
-    45,
-    55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    40,
-    15,
-    29,
-    null,
-    50,
-    null,
-    16,
-    28,
-    30,
-    45,
-    55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))).toEqual([
-    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
-  ]);
-  expect(tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))).toEqual([
-    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
-  ]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.ITERATIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(
+    tree.bfs(node => node, tree.root, IterationType.RECURSIVE).map(node => (node === null ? null : node.key))
+  ).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    15,
-    null,
-    16,
-    29,
-    28,
-    30,
-    40,
-    null,
-    50,
-    45,
-    55
-  ]);
-  expect(tree.dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))).toEqual([
-    35,
-    20,
-    15,
-    null,
-    16,
-    29,
-    28,
-    30,
-    40,
-    null,
-    50,
-    45,
-    55
+  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55
   ]);
+  expect(
+    tree.dfs(node => node, 'pre', tree.root, IterationType.ITERATIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
+  expect(
+    tree.dfs(node => node, 'pre', tree.root, IterationType.RECURSIVE, true).map(node => (node ? node.key : null))
+  ).toEqual([35, 20, 15, null, 16, 29, 28, 30, 40, null, 50, 45, 55]);
 
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
-  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([
+    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
+  expect(tree.bfs(node => node.key, tree.root, IterationType.ITERATIVE)).toEqual([
+    35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
+  ]);
 
   expect(tree.listLevels(node => node.key)).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
 
@@ -417,7 +381,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>({iterationType: IterationType.RECURSIVE});
+    tree = new BinaryTree<string>({ iterationType: IterationType.RECURSIVE });
   });
 
   afterEach(() => {
@@ -560,7 +524,13 @@ describe('BinaryTree', () => {
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value, false, tree.root, IterationType.RECURSIVE);
+    const nodesRec = tree.getNodes(
+      'B',
+      (node: BinaryTreeNode<string>) => node.value,
+      false,
+      tree.root,
+      IterationType.RECURSIVE
+    );
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);

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

@@ -1,5 +1,5 @@
-import {BST, BSTNode, CP, IterationType} from '../../../../src';
-import {isDebugTest} from '../../../config';
+import { BST, BSTNode, CP, IterationType } from '../../../../src';
+import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
@@ -191,23 +191,23 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objBST.addMany(
@@ -236,7 +236,7 @@ describe('BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({key: 15, keyA: 15});
+    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -395,7 +395,7 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST({iterationType: IterationType.RECURSIVE});
+    const bst = new BST({ iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
     bst.add(11, 11);
     bst.add(3, 3);
@@ -582,23 +582,23 @@ describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
     const values = [
-      {key: 15, keyA: 15},
-      {key: 1, keyA: 1},
-      {key: 8, keyA: 8},
-      {key: 13, keyA: 13},
-      {key: 16, keyA: 16},
-      {key: 2, keyA: 2},
-      {key: 6, keyA: 6},
-      {key: 9, keyA: 9},
-      {key: 12, keyA: 12},
-      {key: 14, keyA: 14},
-      {key: 4, keyA: 4},
-      {key: 7, keyA: 7},
-      {key: 10, keyA: 10},
-      {key: 5, keyA: 5}
+      { key: 15, keyA: 15 },
+      { key: 1, keyA: 1 },
+      { key: 8, keyA: 8 },
+      { key: 13, keyA: 13 },
+      { key: 16, keyA: 16 },
+      { key: 2, keyA: 2 },
+      { key: 6, keyA: 6 },
+      { key: 9, keyA: 9 },
+      { key: 12, keyA: 12 },
+      { key: 14, keyA: 14 },
+      { key: 4, keyA: 4 },
+      { key: 7, keyA: 7 },
+      { key: 10, keyA: 10 },
+      { key: 5, keyA: 5 }
     ];
 
     objBST.addMany(
@@ -614,7 +614,7 @@ describe('BST operations test recursively', () => {
     expect(objBST.has(6)).toBe(true);
 
     const node6 = objBST.getNode(6);
-    expect(objBST.get(6)).toEqual({key: 6, keyA: 6});
+    expect(objBST.get(6)).toEqual({ key: 6, keyA: 6 });
     expect(node6 && objBST.getHeight(node6)).toBe(2);
     expect(node6 && objBST.getDepth(node6)).toBe(3);
 
@@ -628,7 +628,7 @@ describe('BST operations test recursively', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({key: 15, keyA: 15});
+    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -843,7 +843,11 @@ describe('BST Performance test', function () {
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
     expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([6, 5, 7]);
+    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6, 5, 7
+    ]);
+    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([
+      6, 5, 7
+    ]);
   });
 });

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

@@ -1,4 +1,4 @@
-import {AVLTree, BST} from '../../../../src';
+import { AVLTree, BST } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
@@ -30,26 +30,26 @@ describe('Overall BinaryTree Test', () => {
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<{ key: number; keyA: number }>();
-    objBST.add(11, {key: 11, keyA: 11});
-    objBST.add(3, {key: 3, keyA: 3});
+    objBST.add(11, { key: 11, keyA: 11 });
+    objBST.add(3, { key: 3, keyA: 3 });
 
     objBST.addMany(
       [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5],
       [
-        {key: 15, keyA: 15},
-        {key: 1, keyA: 1},
-        {key: 8, keyA: 8},
-        {key: 13, keyA: 13},
-        {key: 16, keyA: 16},
-        {key: 2, keyA: 2},
-        {key: 6, keyA: 6},
-        {key: 9, keyA: 9},
-        {key: 12, keyA: 12},
-        {key: 14, keyA: 14},
-        {key: 4, keyA: 4},
-        {key: 7, keyA: 7},
-        {key: 10, keyA: 10},
-        {key: 5, keyA: 5}
+        { key: 15, keyA: 15 },
+        { key: 1, keyA: 1 },
+        { key: 8, keyA: 8 },
+        { key: 13, keyA: 13 },
+        { key: 16, keyA: 16 },
+        { key: 2, keyA: 2 },
+        { key: 6, keyA: 6 },
+        { key: 9, keyA: 9 },
+        { key: 12, keyA: 12 },
+        { key: 14, keyA: 14 },
+        { key: 4, keyA: 4 },
+        { key: 7, keyA: 7 },
+        { key: 10, keyA: 10 },
+        { key: 5, keyA: 5 }
       ]
     );
 

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

@@ -1,7 +1,7 @@
-import {IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode} from '../../../../src';
-import {getRandomInt, getRandomIntArray, magnitude} from '../../../utils';
-import {isDebugTest} from '../../../config';
-import {OrderedMap} from 'js-sdsl';
+import { IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
+import { isDebugTest } from '../../../config';
+import { OrderedMap } from 'js-sdsl';
 
 const isDebug = isDebugTest;
 
@@ -438,12 +438,12 @@ describe('RedBlackTree', () => {
     expect(tree.size).toBe(51);
     expect(tree.isBST()).toBe(true);
     expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.ITERATIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+      77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
     expect(tree.dfs(n => n.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual([
-      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
-      82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
+      49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
+      77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
     ]);
   });
 
@@ -468,7 +468,7 @@ describe('RedBlackTree', () => {
     // TODO there is a bug when dfs the tree with NIL node
     // expect(tree.isBST()).toBe(true);
   });
-  const {HUNDRED_THOUSAND} = magnitude;
+  const { HUNDRED_THOUSAND } = magnitude;
   const arr = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND, true);
   const competitor = new OrderedMap<number, number>();
 

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

@@ -1,4 +1,4 @@
-import {SegmentTree} from '../../../../src';
+import { SegmentTree } from '../../../../src';
 
 describe('SegmentTree', () => {
   let segmentTree: SegmentTree;