data-structure-typed 2.2.7 → 2.2.8

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

@@ -3,9 +3,9 @@ import { AVLTree, BST, RedBlackTree, TreeMultiMap } from '../../../../src';
 describe('Overall BinaryTree Test', () => {
   it('should perform various operations on BinaryTree', () => {
     const bst = new BST<number>();
-    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.set(11);
+    bst.set(3);
+    bst.setMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
     expect(bst.has(6)).toBe(true); // true
@@ -24,10 +24,10 @@ describe('Overall BinaryTree Test', () => {
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<number, { key: number; keyA: number }>();
-    objBST.add([11, { key: 11, keyA: 11 }]);
-    objBST.add([3, { key: 3, keyA: 3 }]);
+    objBST.set([11, { key: 11, keyA: 11 }]);
+    objBST.set([3, { key: 3, keyA: 3 }]);
 
-    objBST.addMany([
+    objBST.setMany([
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
       [8, { key: 8, keyA: 8 }],
@@ -47,7 +47,7 @@ describe('Overall BinaryTree Test', () => {
     objBST.delete(11);
 
     const avlTree = new AVLTree();
-    avlTree.addMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
+    avlTree.setMany([11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5]);
     avlTree.isAVLBalanced(); // true
     expect(avlTree.isAVLBalanced()).toBe(true); // true
     avlTree.delete(10);
@@ -103,9 +103,9 @@ describe('Overall BinaryTree Test', () => {
       comparator: (a, b) => b - a
     });
     expect(avl.size).toBe(5);
-    avl.add(2);
-    avl.add(5);
-    avl.add(4);
+    avl.set(2);
+    avl.set(5);
+    avl.set(4);
     expect(avl.root?.key).toBe(3);
     expect(avl.root?.left?.key).toBe(7);
     expect(avl.root?.left?.left?.key).toBe(9);
@@ -145,11 +145,11 @@ describe('Overall BinaryTree Test', () => {
       iterationType: 'RECURSIVE'
     });
     expect(tmm.size).toBe(5);
-    tmm.add(2);
-    tmm.add(2);
-    tmm.add(2);
-    tmm.add(5);
-    tmm.add(4);
+    tmm.set(2);
+    tmm.set(2);
+    tmm.set(2);
+    tmm.set(5);
+    tmm.set(4);
     expect(tmm.root?.key).toBe(3);
     expect(tmm.root?.left?.key).toBe(1);
     expect(tmm.root?.left?.left?.key).toBe(NaN);
@@ -190,11 +190,11 @@ describe('Overall BinaryTree Test', () => {
       iterationType: 'RECURSIVE'
     });
     expect(rbTree.size).toBe(5);
-    rbTree.add(2);
-    rbTree.add(2);
-    rbTree.add(2);
-    rbTree.add(5);
-    rbTree.add(4);
+    rbTree.set(2);
+    rbTree.set(2);
+    rbTree.set(2);
+    rbTree.set(5);
+    rbTree.set(4);
     expect(rbTree.root?.key).toBe(3);
     expect(rbTree.root?.left?.key).toBe(1);
     expect(rbTree.root?.left?.left?.key).toBe(NaN);

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

@@ -17,9 +17,9 @@ describe('RedBlackTree 1', () => {
 
   describe('add and getNode', () => {
     it('should add and find a node in the rbTree', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
 
       expect(rbTree.getNode(10)).toBeInstanceOf(RedBlackTreeNode);
       expect(rbTree.getNode(20)).toBeInstanceOf(RedBlackTreeNode);
@@ -28,8 +28,8 @@ describe('RedBlackTree 1', () => {
     });
 
     it('should add and find nodes with negative keys', () => {
-      rbTree.add(-10);
-      rbTree.add(-20);
+      rbTree.set(-10);
+      rbTree.set(-20);
 
       expect(rbTree.getNode(-10)).toBeInstanceOf(RedBlackTreeNode);
       expect(rbTree.getNode(-20)).toBeInstanceOf(RedBlackTreeNode);
@@ -38,36 +38,36 @@ describe('RedBlackTree 1', () => {
 
   describe('deleteNode', () => {
     it('should delete a node from the rbTree', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
       rbTree.delete(20);
 
       expect(rbTree.getNode(20)).toBe(undefined);
     });
 
     it('should handle deleting a non-existent node', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
       rbTree.delete(15);
 
       expect(rbTree.getNode(15)).toBe(undefined);
     });
 
     it('should getNode performance O(log n)', () => {
-      for (let i = 0; i < 10; i++) rbTree.add(i);
+      for (let i = 0; i < 10; i++) rbTree.set(i);
       rbTree.getNode(6);
     });
   });
 
   describe('minimum', () => {
     it('should find the minimum node in the rbTree', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
-      rbTree.add(15);
-      rbTree.add(3);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
+      rbTree.set(15);
+      rbTree.set(3);
 
       const minNode = rbTree.getLeftMost(node => node, rbTree.root);
       expect(minNode?.key).toBe(3);
@@ -81,11 +81,11 @@ describe('RedBlackTree 1', () => {
 
   describe('getRightMost', () => {
     it('should find the getRightMost node in the rbTree', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
-      rbTree.add(15);
-      rbTree.add(25);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
+      rbTree.set(15);
+      rbTree.set(25);
 
       const maxNode = rbTree.getRightMost(node => node, rbTree.root);
       expect(maxNode?.key).toBe(25);
@@ -99,11 +99,11 @@ describe('RedBlackTree 1', () => {
 
   describe('getSuccessor', () => {
     it('should find the getSuccessor of a node', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
-      rbTree.add(15);
-      rbTree.add(25);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
+      rbTree.set(15);
+      rbTree.set(25);
 
       const node = rbTree.getNode(15);
       const successorNode = rbTree.getSuccessor(node!);
@@ -112,8 +112,8 @@ describe('RedBlackTree 1', () => {
     });
 
     it('should handle a node with no getSuccessor', () => {
-      rbTree.add(10);
-      rbTree.add(5);
+      rbTree.set(10);
+      rbTree.set(5);
 
       const node = rbTree.getNode(10);
       const successorNode = rbTree.getSuccessor(node!);
@@ -124,11 +124,11 @@ describe('RedBlackTree 1', () => {
 
   describe('getPredecessor', () => {
     it('should find the getPredecessor of a node', () => {
-      rbTree.add(10);
-      rbTree.add(20);
-      rbTree.add(5);
-      rbTree.add(15);
-      rbTree.add(25);
+      rbTree.set(10);
+      rbTree.set(20);
+      rbTree.set(5);
+      rbTree.set(15);
+      rbTree.set(25);
 
       const node = rbTree.getNode(20);
       const predecessorNode = rbTree.getPredecessor(node!);
@@ -137,8 +137,8 @@ describe('RedBlackTree 1', () => {
     });
 
     it('should handle a node with no getPredecessor', () => {
-      rbTree.add(10);
-      rbTree.add(20);
+      rbTree.set(10);
+      rbTree.set(20);
 
       const node = rbTree.getNode(20);
       const predecessorNode = rbTree.getPredecessor(node!);
@@ -160,7 +160,7 @@ describe('RedBlackTree 1', () => {
     }
 
     const rbTree = new RedBlackTree<string, number>();
-    rbTree.addMany([
+    rbTree.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -188,17 +188,17 @@ describe('RedBlackTree 1', () => {
     const rbTree = new RedBlackTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
     expect(rbTree.get(1)).toBe('1');
     expect(rbTree.getNode(1)?.value).toBe('1');
-    rbTree.add(1, 'a');
+    rbTree.set(1, 'a');
     expect(rbTree.get(1)).toBe('a');
-    rbTree.add([1, 'b']);
+    rbTree.set([1, 'b']);
     expect(rbTree.getNode(1)?.value).toBe('b');
     expect(rbTree.get(1)).toBe('b');
     const treeMap = new RedBlackTree<number>([4, 5, [1, '1'], 2, 3]);
     expect(treeMap.get(1)).toBe('1');
     expect(treeMap.getNode(1)?.value).toBe(undefined);
-    treeMap.add(1, 'a');
+    treeMap.set(1, 'a');
     expect(treeMap.get(1)).toBe('a');
-    treeMap.add([1, 'b']);
+    treeMap.set([1, 'b']);
     expect(treeMap.getNode(1)?.value).toBe(undefined);
     expect(treeMap.get(1)).toBe('b');
   });
@@ -212,68 +212,68 @@ describe('RedBlackTree 2', () => {
   });
 
   it('should add nodes into the rbTree', () => {
-    rbTree.add(10);
+    rbTree.set(10);
     expect(rbTree.getNode(10)).toBeDefined();
-    rbTree.add(20);
+    rbTree.set(20);
     expect(rbTree.getNode(20)).toBeDefined();
-    rbTree.add(5);
+    rbTree.set(5);
     expect(rbTree.getNode(5)).toBeDefined();
   });
 
   it('should delete nodes from the rbTree', () => {
-    rbTree.add(10);
-    rbTree.add(20);
-    rbTree.add(5);
+    rbTree.set(10);
+    rbTree.set(20);
+    rbTree.set(5);
     rbTree.delete(20);
     expect(rbTree.getNode(20)).toBe(undefined);
   });
 
   it('should get the successor of a node', () => {
-    rbTree.add(10);
-    rbTree.add(20);
+    rbTree.set(10);
+    rbTree.set(20);
     const node = rbTree.getNode(10);
     const successor = rbTree.getSuccessor(node!);
     expect(successor?.key).toBe(20);
   });
 
   it('should get the predecessor of a node', () => {
-    rbTree.add(10);
-    rbTree.add(20);
+    rbTree.set(10);
+    rbTree.set(20);
     const node = rbTree.getNode(20);
     const predecessor = rbTree.getPredecessor(node!);
     expect(predecessor?.key).toBe(20);
   });
 
   it('should rotate nodes to the left', () => {
-    rbTree.add(10);
-    rbTree.add(20);
-    rbTree.add(5);
+    rbTree.set(10);
+    rbTree.set(20);
+    rbTree.set(5);
     const node = rbTree.getNode(10);
-    rbTree.add(15);
+    rbTree.set(15);
     // Verify that rotation has occurred
     expect(node?.left?.key).toBe(5);
     expect(node?.right?.key).toBe(20);
   });
 
   it('should rotate nodes to the right', () => {
-    rbTree.add(10);
-    rbTree.add(20);
-    rbTree.add(5);
+    rbTree.set(10);
+    rbTree.set(20);
+    rbTree.set(5);
     const node = rbTree.getNode(20);
-    rbTree.add(25);
+    rbTree.set(25);
     // Verify that rotation has occurred
     expect(node?.left?.key).toBeNaN();
     expect(node?.right?.key).toBe(25);
   });
 
   it('should all node attributes fully conform to the red-black rbTree standards.', () => {
-    rbTree.add(10);
-    rbTree.add(20);
-    rbTree.add(5);
-    rbTree.add(15);
-    rbTree.add(21);
-    rbTree.add(6);
-    rbTree.add(2);
+    rbTree.set(10);
+    rbTree.set(20);
+    rbTree.set(5);
+    rbTree.set(15);
+    rbTree.set(21);
+    rbTree.set(6);
+    rbTree.set(2);
 
     let node10F = rbTree.getNode(10);
     let node20F = rbTree.getNode(20);
@@ -409,31 +409,31 @@ describe('RedBlackTree 2', () => {
   });
 
   it('should fix the rbTree after insertion', () => {
-    rbTree.add(1);
-    rbTree.add(2);
-    rbTree.add(5);
-    rbTree.add(15);
+    rbTree.set(1);
+    rbTree.set(2);
+    rbTree.set(5);
+    rbTree.set(15);
     const node15F = rbTree.getNode(15);
     expect(node15F?.left).toBe(rbTree.NIL);
     expect(node15F?.right).toBe(rbTree.NIL);
     expect(node15F?.parent).toBe(rbTree.getNode(5));
 
-    rbTree.add(25);
-    rbTree.add(10);
-    rbTree.add(8);
-    rbTree.add(28);
-    rbTree.add(111);
-    rbTree.add(12);
+    rbTree.set(25);
+    rbTree.set(10);
+    rbTree.set(8);
+    rbTree.set(28);
+    rbTree.set(111);
+    rbTree.set(12);
     rbTree.delete(2);
-    rbTree.add(22);
-    rbTree.add(50);
-    rbTree.add(155);
-    rbTree.add(225);
+    rbTree.set(22);
+    rbTree.set(50);
+    rbTree.set(155);
+    rbTree.set(225);
     const node225F = rbTree.getNode(225);
     expect(node225F?.left).toBe(rbTree.NIL);
     expect(node225F?.right).toBe(rbTree.NIL);
     expect(node225F?.parent?.key).toBe(155);
-    rbTree.add(7);
+    rbTree.set(7);
     if (isDebug) rbTree.print();
 
     const node15S = rbTree.getNode(15);
@@ -448,9 +448,9 @@ describe('RedBlackTree 2', () => {
     const node15T = rbTree.getNode(15);
     expect(node15T).toBe(undefined);
 
-    rbTree.add(23);
-    rbTree.add(33);
-    rbTree.add(15);
+    rbTree.set(23);
+    rbTree.set(33);
+    rbTree.set(15);
 
     const nodeLM = rbTree.getLeftMost();
     expect(nodeLM).toBe(1);
@@ -469,19 +469,19 @@ describe('RedBlackTree 2', () => {
     expect(node225S?.parent?.key).toBe(155);
     // TODO
     // expect(rbTree.getNode(0)).toBe(undefined);
-    rbTree.add(2);
-    rbTree.add(3);
-    rbTree.add(4);
-    rbTree.add(6);
-    rbTree.add(9);
-    rbTree.add(11);
-    rbTree.add(13);
-    rbTree.add(14);
-    rbTree.add(16);
-    rbTree.add(17);
-    rbTree.add(18);
-    rbTree.add(19);
-    rbTree.add(110);
+    rbTree.set(2);
+    rbTree.set(3);
+    rbTree.set(4);
+    rbTree.set(6);
+    rbTree.set(9);
+    rbTree.set(11);
+    rbTree.set(13);
+    rbTree.set(14);
+    rbTree.set(16);
+    rbTree.set(17);
+    rbTree.set(18);
+    rbTree.set(19);
+    rbTree.set(110);
 
     if (isDebug) rbTree.print();
 
@@ -494,7 +494,7 @@ describe('RedBlackTree 2', () => {
 
   it('should fix the rbTree after insertion and deletion', () => {
     for (let i = 0; i < 100; i++) {
-      rbTree.add(i);
+      rbTree.set(i);
     }
     for (let i = 0; i < 49; i++) {
       rbTree.delete(i);
@@ -516,7 +516,7 @@ describe('RedBlackTree 2', () => {
 
   it('should fix the rbTree after large scale insertion and deletion', () => {
     for (let i = 0; i < 10000; i++) {
-      rbTree.add(i);
+      rbTree.set(i);
     }
     for (let i = 0; i < 10000; i++) {
       rbTree.delete(i);
@@ -528,7 +528,7 @@ describe('RedBlackTree 2', () => {
 
     rbTree.clear();
     for (let i = 0; i < 1000; i++) {
-      rbTree.add(getRandomInt(-100, 1000));
+      rbTree.set(getRandomInt(-100, 1000));
       rbTree.delete(getRandomInt(-100, 1000));
     }
 
@@ -543,7 +543,7 @@ describe('RedBlackTree 2', () => {
     rbTree.clear();
     const tS = performance.now();
     for (let i = 0; i < arr.length; i++) {
-      rbTree.add(arr[i]);
+      rbTree.set(arr[i]);
     }
     if (isDebug) console.log(performance.now() - tS);
 
@@ -556,19 +556,19 @@ describe('RedBlackTree 2', () => {
   });
 
   it('duplicates', () => {
-    rbTree.addMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
+    rbTree.setMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
     if (isDebug) rbTree.print();
 
     expect(rbTree.size).toBe(8);
     expect(rbTree.isBST()).toBe(true);
     expect(rbTree.isAVLBalanced()).toBe(true);
-    rbTree.addMany([10, 5, 2, 11]);
+    rbTree.setMany([10, 5, 2, 11]);
     expect(rbTree.size).toBe(10);
     expect(rbTree.isBST()).toBe(true);
     expect(rbTree.isAVLBalanced()).toBe(true);
 
     rbTree.clear();
-    rbTree.addMany([10, 20, 30, 40, 50, 60]);
+    rbTree.setMany([10, 20, 30, 40, 50, 60]);
     expect(rbTree.isAVLBalanced()).toBe(false);
   });
 
@@ -581,7 +581,7 @@ describe('RedBlackTree 2', () => {
     });
     it('The structure remains normal after random deletion', function () {
       for (let i = 0; i < inputSize; i++) {
-        rbTree.add(i);
+        rbTree.set(i);
       }
 
       for (let i = 0; i < inputSize; i++) {
@@ -607,7 +607,7 @@ describe('RedBlackTree 2', () => {
       for (let i = 0; i < inputSize; i++) {
         const num = getRandomInt(0, inputSize - 1);
         if (i === 0 && isDebug) console.log(`first:`, num);
-        rbTree.add(num);
+        rbTree.set(num);
       }
 
       for (let i = 0; i < inputSize; i++) {
@@ -634,9 +634,9 @@ describe('RedBlackTree 2', () => {
     let rbTree: RedBlackTree<number, string>;
     beforeEach(() => {
       rbTree = new RedBlackTree();
-      rbTree.add([1, 'a']);
-      rbTree.add(2, 'b');
-      rbTree.add([3, 'c']);
+      rbTree.set([1, 'a']);
+      rbTree.set(2, 'b');
+      rbTree.set([3, 'c']);
     });
 
     it('The node obtained by get Node should match the node type', () => {
@@ -706,59 +706,59 @@ describe('RedBlackTree - _deleteFixup', () => {
   });
 
   it('should handle deleting a red leaf node', () => {
-    rbTree.add(10, 10);
-    rbTree.add(5, 5); // Red leaf
-    rbTree.add(20, 20);
+    rbTree.set(10, 10);
+    rbTree.set(5, 5); // Red leaf
+    rbTree.set(20, 20);
 
     expect(rbTree.delete(5)).toHaveLength(1); // Delete red leaf
     expect(rbTree.root?.left).toBe(rbTree.NIL); // Left child should be NIL
   });
 
   it('should handle deleting a black leaf node', () => {
-    rbTree.add(10, 10);
-    rbTree.add(5, 5); // Black node
-    rbTree.add(20, 20);
-    rbTree.add(1, 1); // Black leaf node
+    rbTree.set(10, 10);
+    rbTree.set(5, 5); // Black node
+    rbTree.set(20, 20);
+    rbTree.set(1, 1); // Black leaf node
 
     expect(rbTree.delete(1)).toHaveLength(1); // Delete black leaf
     expect(rbTree.root?.left?.left).toBe(rbTree.NIL);
   });
 
   it('should handle deleting black node with red sibling', () => {
-    rbTree.add(10, 10);
-    rbTree.add(5, 5); // Black node
-    rbTree.add(20, 20); // Red sibling
-    rbTree.add(25, 25); // Force the sibling to be red
+    rbTree.set(10, 10);
+    rbTree.set(5, 5); // Black node
+    rbTree.set(20, 20); // Red sibling
+    rbTree.set(25, 25); // Force the sibling to be red
 
     expect(rbTree.delete(5)).toHaveLength(1); // Delete black node
     expect(rbTree.root?.right?.color).toBe('BLACK'); // Ensure sibling color is black after fixup
   });
 
   it('should handle deleting black node with black sibling', () => {
-    rbTree.add(10, 10);
-    rbTree.add(5, 5); // Black node
-    rbTree.add(20, 20); // Black sibling
+    rbTree.set(10, 10);
+    rbTree.set(5, 5); // Black node
+    rbTree.set(20, 20); // Black sibling
 
     expect(rbTree.delete(5)).toHaveLength(1); // Delete black node
     expect(rbTree.root?.left).toBe(rbTree.NIL);
   });
 
   it('should handle deleting the root node', () => {
-    rbTree.add(10, 10); // Root node
-    rbTree.add(5, 5);
-    rbTree.add(20, 20);
+    rbTree.set(10, 10); // Root node
+    rbTree.set(5, 5);
+    rbTree.set(20, 20);
 
     expect(rbTree.delete(10)).toHaveLength(1); // Delete root node
     expect(rbTree.root?.key).toBe(20); // New root should be 20
   });
 
   it('should handle complex case with multiple rotations', () => {
-    rbTree.add(10, 10);
-    rbTree.add(5, 5);
-    rbTree.add(15, 15);
-    rbTree.add(12, 12);
-    rbTree.add(18, 18);
-    rbTree.add(16, 16);
+    rbTree.set(10, 10);
+    rbTree.set(5, 5);
+    rbTree.set(15, 15);
+    rbTree.set(12, 12);
+    rbTree.set(18, 18);
+    rbTree.set(16, 16);
 
     // Delete a node that will cause rotations and color changes
     expect(rbTree.delete(5)).toHaveLength(1);
@@ -773,15 +773,15 @@ describe('RedBlackTree - _deleteFixup', () => {
     const rbTree = new RedBlackTree<number, number>();
 
     // Build a rbTree that will require complex fixup
-    rbTree.add(20, 20);
-    rbTree.add(10, 10);
-    rbTree.add(30, 30);
-    rbTree.add(5, 5);
-    rbTree.add(15, 15);
-    rbTree.add(25, 25);
-    rbTree.add(35, 35);
-    rbTree.add(2, 2);
-    rbTree.add(8, 8);
+    rbTree.set(20, 20);
+    rbTree.set(10, 10);
+    rbTree.set(30, 30);
+    rbTree.set(5, 5);
+    rbTree.set(15, 15);
+    rbTree.set(25, 25);
+    rbTree.set(35, 35);
+    rbTree.set(2, 2);
+    rbTree.set(8, 8);
 
     // This deletion should trigger a complex fixup
     rbTree.delete(2);