data-structure-typed 1.50.3 → 1.50.5

package/test/performance/reportor.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs';
 import * as fastGlob from 'fast-glob';
 import { Color, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
+import * as console from 'console';
 
 const args = process.argv.slice(2);
 
@@ -171,7 +172,48 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
   });
 }
 
-performanceTests.forEach(item => {
+const order = [
+  'heap',
+  'rb-tree',
+  'queue',
+  'deque',
+  'hash-map',
+  'trie',
+  'avl-tree',
+  'binary-tree-overall',
+  'directed-graph',
+  'doubly-linked-list',
+  'singly-linked-list',
+  'priority-queue',
+  'stack'
+];
+
+const sortedPerformanceTests = [...performanceTests].sort((a, b) => {
+  const indexA = order.indexOf(a.testName);
+  const indexB = order.indexOf(b.testName);
+
+  // If both a and b are in the order, sort them according to their indices in the order.
+  if (indexA !== -1 && indexB !== -1) {
+    return indexA - indexB;
+  }
+
+  // If there is only 'a' in the order, then place 'b' in front.
+  if (indexA !== -1) {
+    return 1;
+  }
+
+  // If only b is in the order, then a should be placed before it.
+  if (indexB !== -1) {
+    return -1;
+  }
+
+  // If neither a nor b are in order, keep their original order
+  return 0;
+});
+
+console.log(`${GREEN} Found tests${END}: ${sortedPerformanceTests.map(test => test.testName)}`);
+
+sortedPerformanceTests.forEach(item => {
   const { suite, testName, file } = item;
 
   console.log(coloredLabeled('Running', file));

package/test/unit/data-structures/binary-tree/{tree-multimap.test.ts → avl-tree-multi-map.test.ts}

@@ -1,20 +1,20 @@
 import {
+  AVLTreeMultiMap,
+  AVLTreeMultiMapNode,
   AVLTreeNode,
   BinaryTreeNode,
   BSTNode,
   CP,
-  IterationType,
-  TreeMultimap,
-  TreeMultimapNode
+  IterationType
 } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
 
-describe('TreeMultimap count', () => {
-  let tm: TreeMultimap<number>;
+describe('AVLTreeMultiMap count', () => {
+  let tm: AVLTreeMultiMap<number>;
   beforeEach(() => {
-    tm = new TreeMultimap<number>();
+    tm = new AVLTreeMultiMap<number>();
   });
   it('Should added isolated node count ', () => {
     tm.addMany([
@@ -24,7 +24,7 @@ describe('TreeMultimap count', () => {
       [4, 4],
       [5, 5]
     ]);
-    const newNode = new TreeMultimapNode(3, 33, 10);
+    const newNode = new AVLTreeMultiMapNode(3, 33, 10);
     tm.add(newNode);
     expect(tm.count).toBe(15);
   });
@@ -40,11 +40,11 @@ describe('TreeMultimap count', () => {
   });
 });
 
-describe('TreeMultimap operations test1', () => {
+describe('AVLTreeMultiMap operations test1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new TreeMultimap();
+    const treeMultimap = new AVLTreeMultiMap();
 
-    expect(treeMultimap instanceof TreeMultimap);
+    expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
     treeMultimap.add([3, 3]);
     const idAndValues: [number, number][] = [
@@ -66,7 +66,7 @@ describe('TreeMultimap operations test1', () => {
       [5, 5]
     ];
     treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root instanceof TreeMultimapNode);
+    expect(treeMultimap.root instanceof AVLTreeMultiMapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key == 11);
 
@@ -99,17 +99,17 @@ describe('TreeMultimap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(21);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof TreeMultimapNode);
-    if (node15 instanceof TreeMultimapNode) {
+    expect(node15 instanceof AVLTreeMultiMapNode);
+    if (node15 instanceof AVLTreeMultiMapNode) {
       const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
-    expect(node11 instanceof TreeMultimapNode);
-    if (node11 instanceof TreeMultimapNode) {
+    expect(node11 instanceof AVLTreeMultiMapNode);
+    if (node11 instanceof AVLTreeMultiMapNode) {
       const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
       expect(allGreaterNodesAdded);
     }
@@ -257,14 +257,14 @@ describe('TreeMultimap operations test1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(4);
+    expect(treeMultimap.count).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
-    expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
-    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    const objAVLTreeMultiMap = new AVLTreeMultiMap<number, { key: number; keyA: number }>();
+    expect(objAVLTreeMultiMap).toBeInstanceOf(AVLTreeMultiMap);
+    objAVLTreeMultiMap.add([11, { key: 11, keyA: 11 }]);
+    objAVLTreeMultiMap.add([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -282,23 +282,23 @@ describe('TreeMultimap operations test1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(values);
+    objAVLTreeMultiMap.addMany(values);
 
-    expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
+    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
 
-    expect(objTreeMultimap.count).toBe(16);
+    expect(objAVLTreeMultiMap.count).toBe(16);
 
-    expect(objTreeMultimap.has(6)).toBe(true);
+    expect(objAVLTreeMultiMap.has(6)).toBe(true);
   });
 });
 
-describe('TreeMultimap operations test recursively1', () => {
+describe('AVLTreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new TreeMultimap<number>([], { iterationType: IterationType.RECURSIVE });
+    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
 
-    expect(treeMultimap instanceof TreeMultimap);
+    expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
     treeMultimap.add([3, 3]);
     const idAndValues: [number, number][] = [
@@ -320,7 +320,7 @@ describe('TreeMultimap operations test recursively1', () => {
       [5, 5]
     ];
     treeMultimap.addMany(idAndValues);
-    expect(treeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(treeMultimap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
     if (treeMultimap.root) expect(treeMultimap.root.key).toBe(6);
 
@@ -353,17 +353,17 @@ describe('TreeMultimap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
-    expect(lesserSum).toBe(21);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
 
-    expect(node15 instanceof TreeMultimapNode);
-    if (node15 instanceof TreeMultimapNode) {
+    expect(node15 instanceof AVLTreeMultiMapNode);
+    if (node15 instanceof AVLTreeMultiMapNode) {
       const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
-    expect(node11 instanceof TreeMultimapNode);
-    if (node11 instanceof TreeMultimapNode) {
+    expect(node11 instanceof AVLTreeMultiMapNode);
+    if (node11 instanceof AVLTreeMultiMapNode) {
       const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
       expect(allGreaterNodesAdded);
     }
@@ -511,14 +511,14 @@ describe('TreeMultimap operations test recursively1', () => {
     expect(bfsNodes[1].key).toBe(2);
     expect(bfsNodes[2].key).toBe(16);
 
-    expect(treeMultimap.count).toBe(4);
+    expect(treeMultimap.count).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objTreeMultimap = new TreeMultimap<number, { key: number; keyA: number }>();
-    expect(objTreeMultimap).toBeInstanceOf(TreeMultimap);
-    objTreeMultimap.add([11, { key: 11, keyA: 11 }]);
-    objTreeMultimap.add([3, { key: 3, keyA: 3 }]);
+    const objAVLTreeMultiMap = new AVLTreeMultiMap<number, { key: number; keyA: number }>();
+    expect(objAVLTreeMultiMap).toBeInstanceOf(AVLTreeMultiMap);
+    objAVLTreeMultiMap.add([11, { key: 11, keyA: 11 }]);
+    objAVLTreeMultiMap.add([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -536,27 +536,27 @@ describe('TreeMultimap operations test recursively1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objTreeMultimap.addMany(values);
+    objAVLTreeMultiMap.addMany(values);
 
-    expect(objTreeMultimap.root).toBeInstanceOf(TreeMultimapNode);
+    expect(objAVLTreeMultiMap.root).toBeInstanceOf(AVLTreeMultiMapNode);
 
-    if (objTreeMultimap.root) expect(objTreeMultimap.root.key).toBe(6);
+    if (objAVLTreeMultiMap.root) expect(objAVLTreeMultiMap.root.key).toBe(6);
 
-    expect(objTreeMultimap.count).toBe(16);
+    expect(objAVLTreeMultiMap.count).toBe(16);
 
-    expect(objTreeMultimap.has(6)).toBe(true);
+    expect(objAVLTreeMultiMap.has(6)).toBe(true);
   });
 });
 
-describe('TreeMultimap Performance test', function () {
-  const treeMS = new TreeMultimap<number, number>();
+describe('AVLTreeMultiMap Performance test', function () {
+  const treeMS = new AVLTreeMultiMap<number, number>();
   const inputSize = 100000; // Adjust input sizes as needed
 
   beforeEach(() => {
     treeMS.clear();
   });
 
-  it(`Observe the time consumption of TreeMultimap.dfs be good`, function () {
+  it(`Observe the time consumption of AVLTreeMultiMap.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = treeMS.dfs(node => node);
     isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
@@ -574,7 +574,7 @@ describe('TreeMultimap Performance test', function () {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(treeMultimap: TreeMultimap<string, number>) {
+    function checkTreeStructure(treeMultimap: AVLTreeMultiMap<string, number>) {
       expect(treeMultimap.size).toBe(4);
       expect(treeMultimap.root?.key).toBe('2');
       expect(treeMultimap.root?.left?.key).toBe('1');
@@ -585,7 +585,7 @@ describe('TreeMultimap Performance test', function () {
       expect(treeMultimap.root?.right?.right?.key).toBe('5');
     }
 
-    const treeMultimap = new TreeMultimap<string, number>();
+    const treeMultimap = new AVLTreeMultiMap<string, number>();
     treeMultimap.addMany([
       ['2', 2],
       ['4', 4],
@@ -611,10 +611,10 @@ describe('TreeMultimap Performance test', function () {
   });
 });
 
-describe('TreeMultimap iterative methods test', () => {
-  let treeMM: TreeMultimap<number, string>;
+describe('AVLTreeMultiMap iterative methods test', () => {
+  let treeMM: AVLTreeMultiMap<number, string>;
   beforeEach(() => {
-    treeMM = new TreeMultimap<number, string>();
+    treeMM = new AVLTreeMultiMap<number, string>();
     treeMM.add(1, 'a', 10);
     treeMM.add([2, 'b'], undefined, 10);
     treeMM.add([3, 'c'], undefined, 1);

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

@@ -1,4 +1,4 @@
-import { AVLTree, BST, BSTVariant, IterationType, RedBlackTree, TreeMultimap } from '../../../../src';
+import { AVLTree, BST, BSTVariant, IterationType, RedBlackTree, TreeMultiMap } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
@@ -146,10 +146,9 @@ describe('Overall BinaryTree Test', () => {
     expect(clonedAVL.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
   });
 
-  it('Should clone a TreeMultimap works fine', () => {
-    const tmm = new TreeMultimap<number>([3, 6, 7, 1, 9], {
+  it('Should clone a TreeMultiMap works fine', () => {
+    const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
       iterationType: IterationType.RECURSIVE,
-      variant: BSTVariant.INVERSE,
       extractor: key => key
     });
     expect(tmm.size).toBe(5);
@@ -159,40 +158,40 @@ describe('Overall BinaryTree Test', () => {
     tmm.add(5);
     tmm.add(4);
     expect(tmm.count).toBe(10);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(7);
-    expect(tmm.root?.left?.left?.key).toBe(9);
-    expect(tmm.root?.right?.key).toBe(1);
-    expect(tmm.root?.right?.left?.key).toBe(2);
-    expect(tmm.getNodeByKey(7)?.left?.key).toBe(9);
-    expect(tmm.getHeight()).toBe(3);
+    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.left?.key).toBe(1);
+    expect(tmm.root?.left?.left?.key).toBe(NaN);
+    expect(tmm.root?.right?.key).toBe(7);
+    expect(tmm.root?.right?.left?.key).toBe(NaN);
+    expect(tmm.getNodeByKey(7)?.left?.key).toBe(NaN);
+    expect(tmm.getHeight()).toBe(5);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(true);
     expect(tmm.delete(7)[0].deleted?.key).toBe(7);
     expect(tmm.has(7)).toBe(false);
     expect(tmm.size).toBe(7);
     expect(tmm.count).toBe(9);
-    expect(tmm.root?.key).toBe(3);
-    expect(tmm.root?.left?.key).toBe(5);
-    expect(tmm.root?.right?.key).toBe(1);
-    expect(tmm.root?.right?.left?.key).toBe(2);
-    expect(tmm.getNodeByKey(6)?.left?.key).toBe(undefined);
-    expect(tmm.getHeight()).toBe(3);
+    expect(tmm.root?.key).toBe(6);
+    expect(tmm.root?.left?.key).toBe(1);
+    expect(tmm.root?.right?.key).toBe(9);
+    expect(tmm.root?.right?.left?.key).toBe(NaN);
+    expect(tmm.getNodeByKey(6)?.left?.key).toBe(1);
+    expect(tmm.getHeight()).toBe(5);
     expect(tmm.has(9)).toBe(true);
     expect(tmm.has(7)).toBe(false);
-    expect(tmm.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
+    expect(tmm.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
     const clonedTMM = tmm.clone();
     expect(clonedTMM.size).toBe(7);
     expect(clonedTMM.count).toBe(9);
-    expect(clonedTMM.root?.key).toBe(3);
-    expect(clonedTMM.root?.left?.key).toBe(5);
-    expect(clonedTMM.root?.right?.key).toBe(1);
-    expect(clonedTMM.root?.right?.left?.key).toBe(2);
-    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(undefined);
-    expect(clonedTMM.getHeight()).toBe(3);
+    expect(clonedTMM.root?.key).toBe(6);
+    expect(clonedTMM.root?.left?.key).toBe(1);
+    expect(clonedTMM.root?.right?.key).toBe(9);
+    expect(clonedTMM.root?.right?.left?.key).toBe(NaN);
+    expect(clonedTMM.getNodeByKey(6)?.left?.key).toBe(1);
+    expect(clonedTMM.getHeight()).toBe(5);
     expect(clonedTMM.has(9)).toBe(true);
     expect(clonedTMM.has(7)).toBe(false);
-    expect(clonedTMM.bfs()).toEqual([3, 5, 1, 9, 4, 2, 6]);
+    expect(clonedTMM.bfs()).toEqual([6, 1, 9, 3, 2, 5, 4]);
   });
 
   it('Should clone a RedBlackTree works fine', () => {