data-structure-typed 1.47.6 → 1.47.7

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

@@ -5,7 +5,7 @@ describe('AVL Tree Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const tree = new AVLTree<number>();
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     tree.add(null);
     const node6 = tree.getNode(6);
@@ -114,7 +114,7 @@ describe('AVL Tree Test recursively', () => {
     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 });
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     const node6 = tree.getNode(6);
 
@@ -230,7 +230,7 @@ describe('AVLTree APIs test', () => {
     avl.add(node2);
     const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
     avl.add(node3);
-    avl.add(node3, { id: 3, text: 'text33' });
+    avl.add([3, { id: 3, text: 'text33' }]);
 
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -240,26 +240,26 @@ describe('AVLTree APIs test', () => {
 describe('AVLTree', () => {
   it('should balance the tree using _balanceLR when nodes are added', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTree.add(12, 'F');
+    avlTree.add([12, 'F']);
 
     // You can add more specific assertions to check the tree's balance and structure.
   });
 
   it('should balance the tree using _balanceLR when nodes are deleted', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
-    avlTree.add(12, 'F');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
+    avlTree.add([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTree.delete(3);
@@ -279,7 +279,7 @@ describe('AVLTree', () => {
       avl.add(node2);
       const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
       avl.add(node3);
-      avl.add(node3, { id: 3, text: 'text33' });
+      avl.add([3, { id: 3, text: 'text33' }]);
 
       const bfsRes = avl.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -291,9 +291,9 @@ describe('AVLTree iterative methods test', () => {
   let avl: AVLTree<string>;
   beforeEach(() => {
     avl = new AVLTree();
-    avl.add(1, 'a');
-    avl.add(2, 'b');
-    avl.add(3, 'c');
+    avl.add([1, 'a']);
+    avl.add([2, 'b']);
+    avl.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -1,6 +1,5 @@
-import { BinaryTree, BinaryTreeNode, IterationType } from '../../../../src';
+import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-import { FamilyPosition } from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -137,10 +136,10 @@ describe('BinaryTree', () => {
   });
 
   it('should add and find nodes', () => {
-    tree.add(1, 1);
+    tree.add([1, 1]);
     tree.add(undefined);
-    tree.add(2, 2);
-    tree.add(3, 3);
+    tree.add([2, 2]);
+    tree.add([3, 3]);
 
     expect(tree.has(1)).toBe(true);
     expect(tree.has(2)).toBe(true);
@@ -395,9 +394,9 @@ describe('BinaryTree', () => {
   });
 
   it('should add nodes to the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.size).toBe(3);
     expect(tree.isEmpty()).toBe(false);
@@ -405,9 +404,9 @@ describe('BinaryTree', () => {
   });
 
   it('should clear the BinaryTree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.clear();
 
@@ -417,9 +416,9 @@ describe('BinaryTree', () => {
   });
 
   it('should get nodes by key', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodeA = tree.getNode(5);
     const nodeB = tree.getNode(3);
@@ -431,7 +430,7 @@ describe('BinaryTree', () => {
   });
 
   it('should return null when getting a non-existent node', () => {
-    tree.add(5, 'A');
+    tree.add([5, 'A']);
 
     const node = tree.getNode(3);
 
@@ -439,18 +438,18 @@ describe('BinaryTree', () => {
   });
 
   it('should get the depth of a node', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getDepth(7)).toBe(1);
     expect(tree.getDepth(3)).toBe(1);
   });
 
   it('should get the height of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getHeight()).toBe(1);
     expect(tree.getHeight(undefined, IterationType.RECURSIVE)).toBe(1);
@@ -458,17 +457,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is a binary search tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isBST()).toBe(true);
   });
 
   it('should perform a depth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.dfs();
     expect(result).toEqual([3, 5, 7]);
@@ -476,9 +475,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform a breadth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.bfs(node => node.key);
     expect(result).toEqual([5, 3, 7]);
@@ -486,9 +485,9 @@ describe('BinaryTree', () => {
   });
 
   it('should list levels of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const levels = tree.listLevels();
     expect(levels).toEqual([[5], [3, 7]]);
@@ -496,9 +495,9 @@ describe('BinaryTree', () => {
   });
 
   it('should delete nodes from the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(3);
 
@@ -507,17 +506,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is perfectly balanced', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isPerfectlyBalanced()).toBe(true);
   });
 
   it('should get nodes by a custom callback', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodes = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value);
 
@@ -537,9 +536,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform Morris traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.iterationType = IterationType.ITERATIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
@@ -553,9 +552,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform delete all', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(5);
     tree.delete(7);
@@ -570,9 +569,9 @@ describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<string>;
   beforeEach(() => {
     binaryTree = new BinaryTree();
-    binaryTree.add(1, 'a');
-    binaryTree.add(2, 'b');
-    binaryTree.add(3, 'c');
+    binaryTree.add([1, 'a']);
+    binaryTree.add([2, 'b']);
+    binaryTree.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -7,10 +7,10 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST();
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
-    const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, idsAndValues, false);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
+    const idsAndValues: [number, number][] = [[15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
+    bst.addMany(idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -191,30 +191,26 @@ 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 });
-    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 }
+    objBST.add([11, { key: 11, keyA: 11 }]);
+    objBST.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number; keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
-    objBST.addMany(
-      values.map(item => item.key),
-      values,
-      false
-    );
+    objBST.addMany(values, false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -395,12 +391,12 @@ 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<number>([], { iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
     const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, idsAndValues, false);
+    bst.addMany(idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -414,11 +410,11 @@ describe('BST operations test recursively', () => {
     expect(node6 && bst.getDepth(6)).toBe(3);
 
     const nodeId10 = bst.getNode(10);
-    expect(bst.get(10)).toBe(10);
+    expect(bst.get(10)).toBe(undefined);
     expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = bst.getNode(9, node => node.value);
-    expect(nodeVal9?.key).toBe(9);
+    expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
@@ -582,27 +578,26 @@ 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 });
-    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 }
+    objBST.add([11, { key: 11, keyA: 11 }]);
+    objBST.add([3, { key: 3, keyA: 3 }]);
+    const values: [number, { key: number; keyA: number }][] = [
+      [15, { key: 15, keyA: 15 }],
+      [1, { key: 1, keyA: 1 }],
+      [8, { key: 8, keyA: 8 }],
+      [13, { key: 13, keyA: 13 }],
+      [16, { key: 16, keyA: 16 }],
+      [2, { key: 2, keyA: 2 }],
+      [6, { key: 6, keyA: 6 }],
+      [9, { key: 9, keyA: 9 }],
+      [12, { key: 12, keyA: 12 }],
+      [14, { key: 14, keyA: 14 }],
+      [4, { key: 4, keyA: 4 }],
+      [7, { key: 7, keyA: 7 }],
+      [10, { key: 10, keyA: 10 }],
+      [5, { key: 5, keyA: 5 }]
     ];
 
     objBST.addMany(
-      values.map(item => item.key),
       values,
       false
     );
@@ -834,7 +829,7 @@ describe('BST Performance test', function () {
 
   it('should the lastKey of a BST to be the largest key', function () {
     const bst = new BST();
-    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
+    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], false);
     expect(bst.lastKey()).toBe(9);
   });
 
@@ -856,9 +851,9 @@ describe('BST iterative methods test', () => {
   let bst: BST<string>;
   beforeEach(() => {
     bst = new BST();
-    bst.add(1, 'a');
-    bst.add(2, 'b');
-    bst.add(3, 'c');
+    bst.add([1, 'a']);
+    bst.add([2, 'b']);
+    bst.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -5,7 +5,7 @@ describe('Overall BinaryTree Test', () => {
     const bst = new BST();
     bst.add(11);
     bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], false);
     bst.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
@@ -30,26 +30,25 @@ 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 }
+        [15, { key: 15, keyA: 15 }],
+        [1, { key: 1, keyA: 1 }],
+        [8, { key: 8, keyA: 8 }],
+        [13, { key: 13, keyA: 13 }],
+        [16, { key: 16, keyA: 16 }],
+        [2, { key: 2, keyA: 2 }],
+        [6, { key: 6, keyA: 6 }],
+        [9, { key: 9, keyA: 9 }],
+        [12, { key: 12, keyA: 12 }],
+        [14, { key: 14, keyA: 14 }],
+        [4, { key: 4, keyA: 4 }],
+        [7, { key: 7, keyA: 7 }],
+        [10, { key: 10, keyA: 10 }],
+        [5, { key: 5, keyA: 5 }]
       ]
     );
 

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

@@ -510,9 +510,9 @@ describe('RedBlackTree iterative methods test', () => {
   let rbTree: RedBlackTree<string>;
   beforeEach(() => {
     rbTree = new RedBlackTree();
-    rbTree.add(1, 'a');
-    rbTree.add(2, 'b');
-    rbTree.add(3, 'c');
+    rbTree.add([1, 'a']);
+    rbTree.add([2, 'b']);
+    rbTree.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {