data-structure-typed 1.50.7 → 1.50.9

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BSTNode, IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
 
@@ -53,6 +53,11 @@ describe('RedBlackTree 1', () => {
 
       expect(rbTree.getNode(15)).toBe(undefined);
     });
+
+    it('should getNode performance O(log n)', () => {
+      for (let i = 0; i < 10; i++) rbTree.add(i);
+      rbTree.getNode(6);
+    });
   });
 
   describe('minimum', () => {
@@ -258,42 +263,42 @@ describe('RedBlackTree 2', () => {
     let node6F = rbTree.getNode(6);
     let node2F = rbTree.getNode(2);
     expect(node10F?.key).toBe(10);
-    expect(node10F?.color).toBe(RBTNColor.BLACK);
+    expect(node10F?.color).toBe('BLACK');
     expect(node10F?.left).toBe(node5F);
     expect(node10F?.right).toBe(node20F);
     expect(node10F?.parent).toBe(undefined);
     expect(node20F?.key).toBe(20);
-    expect(node20F?.color).toBe(RBTNColor.BLACK);
+    expect(node20F?.color).toBe('BLACK');
     expect(node20F?.left).toBe(node15F);
     expect(node20F?.right).toBe(node21F);
     expect(node20F?.parent).toBe(node10F);
     expect(node5F?.key).toBe(5);
-    expect(node5F?.color).toBe(RBTNColor.BLACK);
+    expect(node5F?.color).toBe('BLACK');
     expect(node5F?.left).toBe(node2F);
     expect(node5F?.right).toBe(node6F);
     expect(node5F?.parent).toBe(node10F);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
-    expect(node21F?.color).toBe(RBTNColor.RED);
+    expect(node21F?.color).toBe('RED');
     expect(node21F?.left).toBe(rbTree.SENTINEL);
     expect(node21F?.right).toBe(rbTree.SENTINEL);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
-    expect(node6F?.color).toBe(RBTNColor.RED);
+    expect(node6F?.color).toBe('RED');
     expect(node6F?.left).toBe(rbTree.SENTINEL);
     expect(node6F?.right).toBe(rbTree.SENTINEL);
     expect(node6F?.parent).toBe(node5F);
     expect(node2F?.key).toBe(2);
-    expect(node2F?.color).toBe(RBTNColor.RED);
+    expect(node2F?.color).toBe('RED');
     expect(node2F?.left).toBe(rbTree.SENTINEL);
     expect(node2F?.right).toBe(rbTree.SENTINEL);
     expect(node2F?.parent).toBe(node5F);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node20F);
@@ -306,38 +311,38 @@ describe('RedBlackTree 2', () => {
     node6F = rbTree.getNode(6);
     node2F = rbTree.getNode(2);
     expect(node10F?.key).toBe(10);
-    expect(node10F?.color).toBe(RBTNColor.BLACK);
+    expect(node10F?.color).toBe('BLACK');
     expect(node10F?.left).toBe(node6F);
     expect(node10F?.right).toBe(node20F);
     expect(node10F?.parent).toBe(undefined);
     expect(node20F?.key).toBe(20);
-    expect(node20F?.color).toBe(RBTNColor.BLACK);
+    expect(node20F?.color).toBe('BLACK');
     expect(node20F?.left).toBe(node15F);
     expect(node20F?.right).toBe(node21F);
     expect(node20F?.parent).toBe(node10F);
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
-    expect(node21F?.color).toBe(RBTNColor.RED);
+    expect(node21F?.color).toBe('RED');
     expect(node21F?.left).toBe(rbTree.SENTINEL);
     expect(node21F?.right).toBe(rbTree.SENTINEL);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
-    expect(node6F?.color).toBe(RBTNColor.BLACK);
+    expect(node6F?.color).toBe('BLACK');
     expect(node6F?.left).toBe(node2F);
     expect(node6F?.right).toBe(rbTree.SENTINEL);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
-    expect(node2F?.color).toBe(RBTNColor.RED);
+    expect(node2F?.color).toBe('RED');
     expect(node2F?.left).toBe(rbTree.SENTINEL);
     expect(node2F?.right).toBe(rbTree.SENTINEL);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node20F);
@@ -350,34 +355,34 @@ describe('RedBlackTree 2', () => {
     node6F = rbTree.getNode(6);
     node2F = rbTree.getNode(2);
     expect(node10F?.key).toBe(10);
-    expect(node10F?.color).toBe(RBTNColor.BLACK);
+    expect(node10F?.color).toBe('BLACK');
     expect(node10F?.left).toBe(node6F);
     expect(node10F?.right).toBe(node21F);
     expect(node10F?.parent).toBe(undefined);
     expect(node20F).toBe(undefined);
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node21F);
     expect(node21F?.key).toBe(21);
-    expect(node21F?.color).toBe(RBTNColor.BLACK);
+    expect(node21F?.color).toBe('BLACK');
     expect(node21F?.left).toBe(node15F);
     expect(node21F?.right).toBe(rbTree.SENTINEL);
     expect(node21F?.parent).toBe(node10F);
     expect(node6F?.key).toBe(6);
-    expect(node6F?.color).toBe(RBTNColor.BLACK);
+    expect(node6F?.color).toBe('BLACK');
     expect(node6F?.left).toBe(node2F);
     expect(node6F?.right).toBe(rbTree.SENTINEL);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
-    expect(node2F?.color).toBe(RBTNColor.RED);
+    expect(node2F?.color).toBe('RED');
     expect(node2F?.left).toBe(rbTree.SENTINEL);
     expect(node2F?.right).toBe(rbTree.SENTINEL);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
-    expect(node15F?.color).toBe(RBTNColor.RED);
+    expect(node15F?.color).toBe('RED');
     expect(node15F?.left).toBe(rbTree.SENTINEL);
     expect(node15F?.right).toBe(rbTree.SENTINEL);
     expect(node15F?.parent).toBe(node21F);
@@ -477,13 +482,13 @@ describe('RedBlackTree 2', () => {
 
     expect(rbTree.size).toBe(51);
     expect(rbTree.isBST()).toBe(true);
-    expect(rbTree.isBST(rbTree.root, IterationType.RECURSIVE)).toBe(true);
+    expect(rbTree.isBST(rbTree.root, 'RECURSIVE')).toBe(true);
 
-    expect(rbTree.dfs(n => n.key, 'in', rbTree.root, IterationType.ITERATIVE)).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, '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
     ]);
-    expect(rbTree.dfs(n => n.key, 'in', rbTree.root, IterationType.RECURSIVE)).toEqual([
+    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, '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
     ]);
@@ -499,7 +504,7 @@ describe('RedBlackTree 2', () => {
 
     expect(rbTree.size).toBe(0);
     expect(rbTree.isBST()).toBe(true);
-    expect(rbTree.dfs(n => n.key, 'in', rbTree.root, IterationType.ITERATIVE)).toEqual([]);
+    expect(rbTree.dfs(n => n.key, 'IN', rbTree.root, 'ITERATIVE')).toEqual([]);
 
     rbTree.clear();
     for (let i = 0; i < 1000; i++) {

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

@@ -1,12 +1,4 @@
-import {
-  BinaryTreeNode,
-  BSTNode,
-  CP,
-  IterationType,
-  RedBlackTreeNode,
-  TreeMultiMap,
-  TreeMultiMapNode
-} from '../../../../src';
+import { BinaryTreeNode, BSTNode, RedBlackTreeNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 import { getRandomInt } from '../../../utils';
 
@@ -30,7 +22,7 @@ describe('TreeMultiMap count', () => {
     const newNode = new TreeMultiMapNode(3, 33, 10);
     tmm.add(newNode);
     expect(tmm.count).toBe(15);
-    expect(tmm.getMutableCount()).toBe(15);
+    expect(tmm.getComputedCount()).toBe(15);
     expect(tmm.getNode(3)?.count).toBe(11);
   });
 
@@ -40,8 +32,8 @@ describe('TreeMultiMap count', () => {
       [2, 2],
       [3, 3]
     ]);
-    tmm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
-    expect(tmm.getMutableCount()).toBe(7);
+    tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
+    expect(tmm.getComputedCount()).toBe(7);
     expect(tmm.count).toBe(3);
   });
 });
@@ -65,7 +57,7 @@ describe('TreeMultiMap operations test1', () => {
     tmm.add([11, 11]);
     tmm.add([3, 3]);
     expect(tmm.count).toBe(2);
-    expect(tmm.getMutableCount()).toBe(2);
+    expect(tmm.getComputedCount()).toBe(2);
     expect(tmm.size).toBe(2);
 
     const keyValuePairs: [number, number][] = [
@@ -90,13 +82,13 @@ describe('TreeMultiMap operations test1', () => {
     tmm.addMany(keyValuePairs);
     expect(tmm.size).toBe(16);
     expect(tmm.count).toBe(18);
-    expect(tmm.getMutableCount()).toBe(18);
+    expect(tmm.getComputedCount()).toBe(18);
     tmm.delete(11);
     expect(tmm.count).toBe(17);
-    expect(tmm.getMutableCount()).toBe(17);
+    expect(tmm.getComputedCount()).toBe(17);
     tmm.delete(3, undefined, true);
     expect(tmm.count).toBe(15);
-    expect(tmm.getMutableCount()).toBe(15);
+    expect(tmm.getComputedCount()).toBe(15);
   });
 
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
@@ -131,7 +123,7 @@ describe('TreeMultiMap operations test1', () => {
 
     expect(tmm.size).toBe(16);
     expect(tmm.count).toBe(18);
-    expect(tmm.getMutableCount()).toBe(18);
+    expect(tmm.getComputedCount()).toBe(18);
 
     expect(tmm.has(6));
     isDebug && tmm.print();
@@ -156,25 +148,25 @@ describe('TreeMultiMap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    node15 && tmm.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
-    tmm.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    tmm.lesserOrGreaterTraverse((node: TreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof TreeMultiMapNode);
     if (node15 instanceof TreeMultiMapNode) {
-      const subTreeAdd = tmm.dfs(node => (node.count += 1), 'pre', 15);
+      const subTreeAdd = tmm.dfs(node => (node.count += 1), 'PRE', 15);
       expect(subTreeAdd);
     }
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = tmm.dfs(node => node, 'in');
+    const dfsInorderNodes = tmm.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(tmm.isPerfectlyBalanced()).toBe(false);
@@ -317,7 +309,7 @@ describe('TreeMultiMap operations test1', () => {
     expect(bfsNodes[2].key).toBe(16);
 
     expect(tmm.count).toBe(6);
-    expect(tmm.getMutableCount()).toBe(8);
+    expect(tmm.getComputedCount()).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -349,7 +341,7 @@ describe('TreeMultiMap operations test1', () => {
     if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(5);
 
     expect(objTreeMultiMap.count).toBe(16);
-    expect(objTreeMultiMap.getMutableCount()).toBe(16);
+    expect(objTreeMultiMap.getComputedCount()).toBe(16);
 
     expect(objTreeMultiMap.has(6)).toBe(true);
   });
@@ -357,7 +349,7 @@ describe('TreeMultiMap operations test1', () => {
 
 describe('TreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const tmm = new TreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
+    const tmm = new TreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     expect(tmm instanceof TreeMultiMap);
     tmm.add([11, 11]);
@@ -387,7 +379,7 @@ describe('TreeMultiMap operations test recursively1', () => {
 
     expect(tmm.size).toBe(16);
     expect(tmm.count).toBe(18);
-    expect(tmm.getMutableCount()).toBe(18);
+    expect(tmm.getComputedCount()).toBe(18);
 
     expect(tmm.has(6));
 
@@ -412,7 +404,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(14);
 
     let subTreeSum = 0;
-    node15 && tmm.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && tmm.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(45);
     let lesserSum = 0;
     expect(tmm.has(9)).toBe(true);
@@ -421,24 +413,24 @@ describe('TreeMultiMap operations test recursively1', () => {
         lesserSum += node.key;
         return node.key;
       },
-      CP.lt,
+      'LT',
       10
     );
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof TreeMultiMapNode);
     if (node15 instanceof TreeMultiMapNode) {
-      const subTreeAdd = tmm.dfs(node => (node.count += 1), 'pre', 15);
+      const subTreeAdd = tmm.dfs(node => (node.count += 1), 'PRE', 15);
       expect(subTreeAdd);
     }
     const node11 = tmm.getNode(11);
     expect(node11 instanceof TreeMultiMapNode);
     if (node11 instanceof TreeMultiMapNode) {
-      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = tmm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
-    const dfsInorderNodes = tmm.dfs(node => node, 'in');
+    const dfsInorderNodes = tmm.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
     expect(tmm.isPerfectlyBalanced()).toBe(false);
@@ -582,7 +574,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     expect(bfsNodes[2].key).toBe(16);
 
     expect(tmm.count).toBe(6);
-    expect(tmm.getMutableCount()).toBe(8);
+    expect(tmm.getComputedCount()).toBe(8);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -614,7 +606,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     if (objTreeMultiMap.root) expect(objTreeMultiMap.root.key).toBe(5);
 
     expect(objTreeMultiMap.count).toBe(16);
-    expect(objTreeMultiMap.getMutableCount()).toBe(16);
+    expect(objTreeMultiMap.getComputedCount()).toBe(16);
 
     expect(objTreeMultiMap.has(6)).toBe(true);
   });
@@ -819,7 +811,7 @@ describe('TreeMultiMap iterative methods test', () => {
 
   test('should clone work well', () => {
     expect(treeMM.count).toBe(21);
-    expect(treeMM.getMutableCount()).toBe(21);
+    expect(treeMM.getComputedCount()).toBe(21);
     const cloned = treeMM.clone();
     expect(cloned.root?.left?.key).toBe(1);
     expect(cloned.root?.right?.value).toBe('c');

package/test/unit/data-structures/priority-queue/priority-queue.test.ts

@@ -42,9 +42,9 @@ describe('PriorityQueue Operation Test', () => {
     const clonedPriorityQueue = minPQ1.clone();
     expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
     expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-    expect(minPQ1.dfs('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
-    expect(minPQ1.dfs('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
-    expect(minPQ1.dfs('pre')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
+    expect(minPQ1.dfs('IN')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
+    expect(minPQ1.dfs('POST')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);
+    expect(minPQ1.dfs('PRE')).toEqual([1, 2, 3, 4, 5, 6, 8, 7]);
   });
 });