data-structure-typed 1.50.7 → 1.50.8

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

@@ -11,23 +11,25 @@ const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1,
 const cOrderedMap = new OrderedMap<number, number>();
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete orderly`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+    const entries = [...rbTree];
+    return entries.length === HUNDRED_THOUSAND;
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add orderly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+    rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} delete randomly`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
     for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
   });
 
@@ -37,15 +39,4 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} getNode randomly`, () => {
-  for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
-});
-
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & iterator`, () => {
-  rbTree.clear();
-  for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-  const entries = [...rbTree];
-  return entries.length === HUNDRED_THOUSAND;
-});
-
 export { suite };

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

@@ -1,12 +1,4 @@
-import {
-  AVLTreeMultiMap,
-  AVLTreeMultiMapNode,
-  AVLTreeNode,
-  BinaryTreeNode,
-  BSTNode,
-  CP,
-  IterationType
-} from '../../../../src';
+import { AVLTreeMultiMap, AVLTreeMultiMapNode, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -36,7 +28,7 @@ describe('AVLTreeMultiMap count', () => {
       [3, 3]
     ]);
     tm.add([2, 2], undefined, 10);
-    tm.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 1);
+    tm.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 1);
     tm.delete(2);
     expect(tm.count).toBe(12);
     expect(tm.getMutableCount()).toBe(16);
@@ -102,7 +94,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -113,7 +105,7 @@ describe('AVLTreeMultiMap operations test1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -299,7 +291,7 @@ describe('AVLTreeMultiMap operations test1', () => {
 
 describe('AVLTreeMultiMap operations test recursively1', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: IterationType.RECURSIVE });
+    const treeMultimap = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     expect(treeMultimap instanceof AVLTreeMultiMap);
     treeMultimap.add([11, 11]);
@@ -356,7 +348,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
-    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), CP.lt, 10);
+    treeMultimap.lesserOrGreaterTraverse((node: AVLTreeMultiMapNode<number>) => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15 instanceof AVLTreeMultiMapNode);
@@ -367,7 +359,7 @@ describe('AVLTreeMultiMap operations test recursively1', () => {
     const node11 = treeMultimap.getNode(11);
     expect(node11 instanceof AVLTreeMultiMapNode);
     if (node11 instanceof AVLTreeMultiMapNode) {
-      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), CP.gt, 11);
+      const allGreaterNodesAdded = treeMultimap.lesserOrGreaterTraverse(node => (node.count += 2), 'GT', 11);
       expect(allGreaterNodesAdded);
     }
 
@@ -572,7 +564,7 @@ describe('AVLTreeMultiMap Performance test', function () {
     }
     isDebug && console.log('---add', performance.now() - start);
     const startL = performance.now();
-    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), CP.lt, inputSize / 2);
+    treeMS.lesserOrGreaterTraverse(node => (node.count += 1), 'LT', inputSize / 2);
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, CP, IterationType } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -28,7 +28,7 @@ describe('AVL Tree Test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), '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.
@@ -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: 'RECURSIVE' });
 
     for (const i of arr) tree.add([i, i]);
 
@@ -136,7 +136,7 @@ describe('AVL Tree Test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), '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.

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

@@ -1,4 +1,4 @@
-import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
+import { BinaryTree, BinaryTreeNode } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
 // import { isDebugTest } from '../../../config';
 
@@ -81,7 +81,7 @@ describe('BinaryTreeNode', () => {
     root.right = rightChild;
 
     expect(rightChild.familyPosition).toBe('RIGHT');
-    expect(isolated.familyPosition).toBe(FamilyPosition.ISOLATED);
+    expect(isolated.familyPosition).toBe('ISOLATED');
     expect(root.familyPosition).toBe('ROOT');
   });
 });
@@ -104,7 +104,7 @@ describe('BinaryTree', () => {
   });
 
   it('should delete nodes', () => {
-    expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1);
+    expect(tree.getHeight(tree.root, 'ITERATIVE')).toBe(-1);
     expect(tree.getMinHeight()).toBe(-1);
     const node1 = tree.createNode(1);
     tree.add(node1);
@@ -132,7 +132,7 @@ describe('BinaryTree', () => {
       const result = tree.delete(node1);
       expect(result).toHaveLength(1);
       expect(tree.size).toBe(4);
-      expect(tree.getMinHeight(tree.root, IterationType.RECURSIVE)).toBe(1);
+      expect(tree.getMinHeight(tree.root, 'RECURSIVE')).toBe(1);
     }
   });
 
@@ -171,16 +171,25 @@ describe('BinaryTree', () => {
     expect(cloned.root?.right?.key).toBe(6);
     expect(cloned.root?.right?.left?.key).toBe(3);
     expect(cloned.root?.right?.right).toBe(null);
-    expect(cloned.dfs(node => node.key, 'pre', cloned.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
-    expect(
-      cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), IterationType.ITERATIVE, true)
-    ).toEqual([6, 3, 7, null]);
-    expect(
-      cloned.dfs(node => (node ? node.key : node), 'pre', cloned.getNode(6), IterationType.ITERATIVE, true)
-    ).toEqual([6, 3, 7, null]);
-    expect(
-      cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), IterationType.RECURSIVE, true)
-    ).toEqual([6, 3, 7, null]);
+    expect(cloned.dfs(node => node.key, 'pre', cloned.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(cloned.dfs(node => (node ? node.key : node), 'pre', cloned.getNode(6), 'ITERATIVE', true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(cloned.dfs(node => (node ? node.key : null), 'pre', cloned.getNode(6), 'RECURSIVE', true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
     cloned.delete(6);
     cloned.delete(3);
     cloned.delete(7);
@@ -234,9 +243,9 @@ describe('BinaryTree', () => {
     tree.add(4);
     tree.add(2);
     expect(tree.getHeight()).toBe(1);
-    tree.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = 'RECURSIVE';
     expect(tree.getHeight()).toBe(1);
-    tree.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = 'ITERATIVE';
 
     tree.add(6);
     tree.add(1);
@@ -252,9 +261,9 @@ describe('BinaryTree', () => {
   it('should getLeftMost', () => {
     tree.addMany([4, 2, 6, 1, 3, 5, 7]);
 
-    const leftMost = tree.getLeftMost(tree.root, IterationType.RECURSIVE);
+    const leftMost = tree.getLeftMost(tree.root, 'RECURSIVE');
     expect(leftMost?.key).toEqual(1);
-    const rightMost = tree.getRightMost(tree.root, IterationType.RECURSIVE);
+    const rightMost = tree.getRightMost(tree.root, 'RECURSIVE');
     expect(rightMost?.key).toEqual(7);
   });
 
@@ -270,37 +279,37 @@ describe('BinaryTree', () => {
       new BinaryTreeNode(4, 4)
     ]);
 
-    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), 'RECURSIVE')).toBe(true);
+    expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
   });
 
   it('should isSubtreeBST', () => {
     tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
 
-    expect(tree.isBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
-    expect(tree.isBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.isBST(tree.getNode(4), 'RECURSIVE')).toBe(true);
+    expect(tree.isBST(tree.getNode(4), 'ITERATIVE')).toBe(true);
     expect(tree.getNodes(2, undefined, false, null)).toEqual([]);
     expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
   it('should sub tree traverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'ITERATIVE')).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'ITERATIVE', false)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), 'RECURSIVE')).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(tree.dfs(node => (node ? node.key : node), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+    expect(tree.dfs(node => (node ? node.key : node), 'pre', tree.getNode(6), 'ITERATIVE', true)).toEqual([
       6,
       3,
       7,
       null
     ]);
-    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), 'RECURSIVE', true)).toEqual([
       6,
       3,
       7,
@@ -360,7 +369,7 @@ describe('BinaryTree Morris Traversal', () => {
 
     expect(result).toEqual(expected);
     expect(tree.dfs(node => node.key, 'in')).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'in', tree.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
@@ -399,57 +408,101 @@ 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, '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, '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, '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, '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([
+  expect(tree.dfs(node => node.key, 'pre', tree.root, '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, 'pre', tree.root, '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, '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([
+  expect(tree.dfs(node => node.key, 'post', tree.root, '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.bfs(node => node.key, tree.root, 'RECURSIVE')).toEqual([35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55]);
+  expect(tree.bfs(node => node.key, tree.root, '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]]);
 
-  expect(tree.listLevels(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+  expect(tree.listLevels(node => node.key, tree.root, 'RECURSIVE')).toEqual([
     [35],
     [20, 40],
     [15, 29, 50],
     [16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => (node ? node.key : null), tree.root, IterationType.ITERATIVE, true)).toEqual([
+  expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'ITERATIVE', true)).toEqual([
     [35],
     [20, 40],
     [15, 29, null, 50],
     [null, 16, 28, 30, 45, 55]
   ]);
-  expect(tree.listLevels(node => (node ? node.key : null), tree.root, IterationType.RECURSIVE, true)).toEqual([
+  expect(tree.listLevels(node => (node ? node.key : null), tree.root, 'RECURSIVE', true)).toEqual([
     [35],
     [20, 40],
     [15, 29, null, 50],
@@ -461,7 +514,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<number, string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<number, string>([], { iterationType: IterationType.RECURSIVE });
+    tree = new BinaryTree<number, string>([], { iterationType: 'RECURSIVE' });
   });
 
   afterEach(() => {
@@ -533,8 +586,8 @@ describe('BinaryTree', () => {
     tree.add([7, 'C']);
 
     expect(tree.getHeight()).toBe(1);
-    expect(tree.getHeight(undefined, IterationType.RECURSIVE)).toBe(1);
-    expect(tree.getMinHeight(undefined, IterationType.RECURSIVE)).toBe(1);
+    expect(tree.getHeight(undefined, 'RECURSIVE')).toBe(1);
+    expect(tree.getMinHeight(undefined, 'RECURSIVE')).toBe(1);
   });
 
   it('should check if the tree is a binary search tree', () => {
@@ -604,7 +657,7 @@ describe('BinaryTree', () => {
     expect(nodes.length).toBe(1);
     expect(nodes[0].key).toBe(3);
 
-    const nodesRec = tree.getNodes('B', node => node.value, false, tree.root, IterationType.RECURSIVE);
+    const nodesRec = tree.getNodes('B', node => node.value, false, tree.root, 'RECURSIVE');
 
     expect(nodesRec.length).toBe(1);
     expect(nodesRec[0].key).toBe(3);
@@ -615,19 +668,19 @@ describe('BinaryTree', () => {
     tree.add([3, 'B']);
     tree.add([7, 'C']);
 
-    tree.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = 'ITERATIVE';
     expect([...tree]).toEqual([
       [3, 'B'],
       [5, 'A'],
       [7, 'C']
     ]);
-    tree.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = 'RECURSIVE';
     expect([...tree]).toEqual([
       [3, 'B'],
       [5, 'A'],
       [7, 'C']
     ]);
-    tree.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = 'ITERATIVE';
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);

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

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode, BSTVariant, CP, IterationType } from '../../../../src';
+import { BinaryTreeNode, BST, BSTNode } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -58,7 +58,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -261,7 +261,7 @@ describe('BST operations test', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -411,7 +411,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<number>([], { iterationType: IterationType.RECURSIVE });
+    const bst = new BST<number>([], { iterationType: 'RECURSIVE' });
     expect(bst).toBeInstanceOf(BST);
     bst.add([11, 11]);
     bst.add([3, 3]);
@@ -448,7 +448,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    bst.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -649,7 +649,7 @@ describe('BST operations test recursively', () => {
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
-    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    objBST.lesserOrGreaterTraverse(node => (lesserSum += node.key), 'LT', 10);
     expect(lesserSum).toBe(45);
 
     expect(node15).toBeInstanceOf(BSTNode);
@@ -869,7 +869,7 @@ describe('BST isBST', function () {
   });
 
   test('isBST when variant is Max', () => {
-    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { variant: BSTVariant.INVERSE });
+    const bst = new BST<number, number>([1, 2, 3, 9, 8, 5, 6, 7, 4], { variant: 'INVERSE' });
     bst.addMany([1, 2, 3, 9, 8, 5, 6, 7, 4]);
     expect(bst.isBST()).toBe(true);
   });
@@ -902,7 +902,7 @@ describe('BST Performance test', function () {
       node => {
         node.key - 1;
       },
-      CP.lt,
+      'LT',
       inputSize / 2
     );
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
@@ -932,10 +932,10 @@ describe('BST Performance test', function () {
   it('should dfs as sub tree traversal, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
-    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), 'ITERATIVE')).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), 'RECURSIVE')).toEqual([6, 5, 7]);
   });
 });
 

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, RedBlackTree, TreeMultiMap } from '../../../../src';
 
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
@@ -63,8 +63,8 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a BST works fine', () => {
     const bst = new BST<number>([3, 6, 7, 1, 9], {
-      iterationType: IterationType.RECURSIVE,
-      variant: BSTVariant.INVERSE,
+      iterationType: 'RECURSIVE',
+      variant: 'INVERSE',
       extractor: key => key
     });
     expect(bst.size).toBe(5);
@@ -104,8 +104,8 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a AVLTree works fine', () => {
     const avl = new AVLTree<number>([3, 6, 7, 1, 9], {
-      iterationType: IterationType.RECURSIVE,
-      variant: BSTVariant.INVERSE,
+      iterationType: 'RECURSIVE',
+      variant: 'INVERSE',
       extractor: key => key
     });
     expect(avl.size).toBe(5);
@@ -148,7 +148,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a TreeMultiMap works fine', () => {
     const tmm = new TreeMultiMap<number>([3, 6, 7, 1, 9], {
-      iterationType: IterationType.RECURSIVE,
+      iterationType: 'RECURSIVE',
       extractor: key => key
     });
     expect(tmm.size).toBe(5);
@@ -197,7 +197,7 @@ describe('Overall BinaryTree Test', () => {
 
   it('Should clone a RedBlackTree works fine', () => {
     const rbTree = new RedBlackTree<number>([3, 6, 7, 1, 9], {
-      iterationType: IterationType.RECURSIVE,
+      iterationType: 'RECURSIVE',
       extractor: key => key
     });
     expect(rbTree.size).toBe(5);

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, RBTNColor, 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', () => {
@@ -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++) {