data-structure-typed 1.50.7 → 1.50.9

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,
@@ -353,36 +362,36 @@ describe('BinaryTree Morris Traversal', () => {
   tree.add(5);
   it('should perform in-order Morris traversal correctly as dfs traversal', () => {
     // Perform in-order Morris traversal
-    const result = tree.morris(node => node.key, 'in');
+    const result = tree.morris(node => node.key, 'IN');
 
     // Expected in-order traversal result
     const expected = [4, 2, 5, 1, 3];
 
     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')).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', () => {
     // Perform pre-order Morris traversal
-    const result = tree.morris(node => node.key, 'pre');
+    const result = tree.morris(node => node.key, 'PRE');
 
     // Expected pre-order traversal result
     const expected = [1, 2, 4, 5, 3];
 
     expect(result).toEqual(expected);
-    expect(tree.dfs(node => node.key, 'pre')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'PRE')).toEqual(expected);
   });
 
   it('should perform post-order Morris traversal correctly as dfs traversal', () => {
     // Perform post-order Morris traversal
-    const result = tree.morris(node => node.key, 'post');
+    const result = tree.morris(node => node.key, 'POST');
 
     // Expected post-order traversal result
     const expected = [4, 5, 2, 3, 1];
 
     expect(result).toEqual([4, 5, 2, 3, 1]);
-    expect(tree.dfs(node => node.key, 'post')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'POST')).toEqual(expected);
   });
 
   it('after morris traversals should the structure of the tree be correct', () => {
@@ -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.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.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.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, 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.key, tree.root, IterationType.RECURSIVE)).toEqual([
+  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.key, tree.root, IterationType.ITERATIVE)).toEqual([
+  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, 'RECURSIVE')).toEqual([
+    35, 20, 15, 16, 29, 28, 30, 40, 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, 'RECURSIVE')).toEqual([
+    16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35
+  ]);
+  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;
@@ -54,11 +54,11 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     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);
@@ -66,7 +66,7 @@ describe('BST operations test', () => {
     const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = bst.dfs(node => node, 'in');
+    const dfsInorderNodes = bst.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
@@ -257,11 +257,11 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     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);
@@ -269,7 +269,7 @@ describe('BST operations test', () => {
     const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = objBST.dfs(node => node, 'in');
+    const dfsInorderNodes = objBST.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
@@ -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]);
@@ -444,11 +444,11 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     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);
@@ -456,7 +456,7 @@ describe('BST operations test recursively', () => {
     const node11 = bst.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = bst.dfs(node => node, 'in');
+    const dfsInorderNodes = bst.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
@@ -645,11 +645,11 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     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);
@@ -657,7 +657,7 @@ describe('BST operations test recursively', () => {
     const node11 = objBST.getNode(11);
     expect(node11).toBeInstanceOf(BSTNode);
 
-    const dfsInorderNodes = objBST.dfs(node => node, 'in');
+    const dfsInorderNodes = objBST.dfs(node => node, 'IN');
     expect(dfsInorderNodes[0].key).toBe(1);
     expect(dfsInorderNodes[dfsInorderNodes.length - 1].key).toBe(16);
 
@@ -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);