data-structure-typed 2.2.7 → 2.2.8

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

@@ -9,7 +9,7 @@ describe('AVLTreeCounter count', () => {
     avlCounter = new AVLTreeCounter<number>();
   });
   it('Should added isolated node count ', () => {
-    avlCounter.addMany([
+    avlCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3],
@@ -17,17 +17,17 @@ describe('AVLTreeCounter count', () => {
       [5, 5]
     ]);
     const newNode = new AVLTreeCounterNode(3, 33, 10);
-    avlCounter.add(newNode);
+    avlCounter.set(newNode);
     expect(avlCounter.count).toBe(15);
   });
 
   it('Should count', () => {
-    avlCounter.addMany([
+    avlCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3]
     ]);
-    avlCounter.add([2, 2], undefined, 10);
+    avlCounter.set([2, 2], undefined, 10);
     avlCounter.lesserOrGreaterTraverse(node => (node.count += 2), 1, 1);
     avlCounter.delete(2);
     expect(avlCounter.count).toBe(12);
@@ -40,8 +40,8 @@ describe('AVLTreeCounter operations test1', () => {
     const avlCounter = new AVLTreeCounter<number>();
 
     expect(avlCounter instanceof AVLTreeCounter);
-    avlCounter.add([11, 11]);
-    avlCounter.add([3, 3]);
+    avlCounter.set([11, 11]);
+    avlCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -60,7 +60,7 @@ describe('AVLTreeCounter operations test1', () => {
       [10, 10],
       [5, 5]
     ];
-    avlCounter.addMany(idAndValues);
+    avlCounter.setMany(idAndValues);
     expect(avlCounter.root instanceof AVLTreeCounterNode);
 
     if (avlCounter.root) expect(avlCounter.root.key == 11);
@@ -258,8 +258,8 @@ describe('AVLTreeCounter operations test1', () => {
   it('should perform various operations on a AVLTreeCounter with object values', () => {
     const objAvlCounter = new AVLTreeCounter<number, { key: number; keyA: number }>();
     expect(objAvlCounter).toBeInstanceOf(AVLTreeCounter);
-    objAvlCounter.add([11, { key: 11, keyA: 11 }]);
-    objAvlCounter.add([3, { key: 3, keyA: 3 }]);
+    objAvlCounter.set([11, { key: 11, keyA: 11 }]);
+    objAvlCounter.set([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -277,7 +277,7 @@ describe('AVLTreeCounter operations test1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objAvlCounter.addMany(values);
+    objAvlCounter.setMany(values);
 
     expect(objAvlCounter.root).toBeInstanceOf(AVLTreeCounterNode);
 
@@ -296,8 +296,8 @@ describe('AVLTreeCounter operations test recursively1', () => {
     });
 
     expect(avlCounter instanceof AVLTreeCounter);
-    avlCounter.add([11, 11]);
-    avlCounter.add([3, 3]);
+    avlCounter.set([11, 11]);
+    avlCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -316,7 +316,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
       [10, 10],
       [5, 5]
     ];
-    avlCounter.addMany(idAndValues);
+    avlCounter.setMany(idAndValues);
     expect(avlCounter.root).toBeInstanceOf(AVLTreeCounterNode);
 
     if (avlCounter.root) expect(avlCounter.root.key).toBe(6);
@@ -514,8 +514,8 @@ describe('AVLTreeCounter operations test recursively1', () => {
   it('should perform various operations on a AVLTreeCounter with object values', () => {
     const objAvlCounter = new AVLTreeCounter<number, { key: number; keyA: number }>();
     expect(objAvlCounter).toBeInstanceOf(AVLTreeCounter);
-    objAvlCounter.add([11, { key: 11, keyA: 11 }]);
-    objAvlCounter.add([3, { key: 3, keyA: 3 }]);
+    objAvlCounter.set([11, { key: 11, keyA: 11 }]);
+    objAvlCounter.set([3, { key: 3, keyA: 3 }]);
     const values: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
@@ -533,7 +533,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
       [5, { key: 5, keyA: 5 }]
     ];
 
-    objAvlCounter.addMany(values);
+    objAvlCounter.setMany(values);
 
     expect(objAvlCounter.root).toBeInstanceOf(AVLTreeCounterNode);
 
@@ -562,7 +562,7 @@ describe('AVLTreeCounter Performance test', function () {
   it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
     const start = performance.now();
     for (let i = 0; i < inputSize; i++) {
-      avlCounter.add(i);
+      avlCounter.set(i);
     }
     if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
@@ -583,7 +583,7 @@ describe('AVLTreeCounter Performance test', function () {
     }
 
     const avlCounter = new AVLTreeCounter<string, number>();
-    avlCounter.addMany([
+    avlCounter.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -612,9 +612,9 @@ describe('AVLTreeCounter iterative methods test', () => {
   let avlCounter: AVLTreeCounter<number, string>;
   beforeEach(() => {
     avlCounter = new AVLTreeCounter<number, string>();
-    avlCounter.add(1, 'a', 10);
-    avlCounter.add([2, 'b'], undefined, 10);
-    avlCounter.add([3, 'c'], undefined, 1);
+    avlCounter.set(1, 'a', 10);
+    avlCounter.set([2, 'b'], undefined, 10);
+    avlCounter.set([3, 'c'], undefined, 1);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -698,7 +698,7 @@ describe('AVLTreeCounter toEntryFn', () => {
     const avlCounter = new AVLTreeCounter<number, number, { obj: { id: number } }>([], {
       toEntryFn: ele => [ele.obj.id, ele.obj.id]
     });
-    avlCounter.addMany([
+    avlCounter.setMany([
       { obj: { id: 1 } },
       { obj: { id: 2 } },
       { obj: { id: 3 } },
@@ -771,7 +771,7 @@ describe('AVLTreeCounter not map mode count', () => {
     avlCounter = new AVLTreeCounter<number>([], { isMapMode: false });
   });
   it('Should added isolated node count ', () => {
-    avlCounter.addMany([
+    avlCounter.setMany([
       [1, 1],
       [2, 2],
       [3, 3],
@@ -779,7 +779,7 @@ describe('AVLTreeCounter not map mode count', () => {
       [5, 5]
     ]);
     const newNode = new AVLTreeCounterNode(3, undefined, 10);
-    avlCounter.add(newNode, 33);
+    avlCounter.set(newNode, 33);
     expect(avlCounter.count).toBe(15);
   });
 });
@@ -789,8 +789,8 @@ describe('AVLTreeCounter not map mode operations test1', () => {
     const avlCounter = new AVLTreeCounter<number>([], { isMapMode: false });
 
     expect(avlCounter instanceof AVLTreeCounter);
-    avlCounter.add([11, 11]);
-    avlCounter.add([3, 3]);
+    avlCounter.set([11, 11]);
+    avlCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -809,7 +809,7 @@ describe('AVLTreeCounter not map mode operations test1', () => {
       [10, 10],
       [5, 5]
     ];
-    avlCounter.addMany(idAndValues);
+    avlCounter.setMany(idAndValues);
     expect(avlCounter.root instanceof AVLTreeCounterNode);
 
     if (avlCounter.root) expect(avlCounter.root.key == 11);
@@ -837,8 +837,8 @@ describe('AVLTreeCounter not map mode operations test recursively1', () => {
     });
 
     expect(avlCounter instanceof AVLTreeCounter);
-    avlCounter.add([11, 11]);
-    avlCounter.add([3, 3]);
+    avlCounter.set([11, 11]);
+    avlCounter.set([3, 3]);
     const idAndValues: [number, number][] = [
       [11, 11],
       [3, 3],
@@ -857,7 +857,7 @@ describe('AVLTreeCounter not map mode operations test recursively1', () => {
       [10, 10],
       [5, 5]
     ];
-    avlCounter.addMany(idAndValues);
+    avlCounter.setMany(idAndValues);
     expect(avlCounter.root).toBeInstanceOf(AVLTreeCounterNode);
 
     if (avlCounter.root) expect(avlCounter.root.key).toBe(6);

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

@@ -10,9 +10,9 @@ describe('AVLTreeMultiMap', () => {
   });
 
   it('Should add and delete values', () => {
-    avlTmm.add(3, 3);
-    avlTmm.add(3, 33);
-    avlTmm.add(3, 333);
+    avlTmm.set(3, 3);
+    avlTmm.set(3, 33);
+    avlTmm.set(3, 333);
     expect(avlTmm.get(3)).toEqual([3, 33, 333]);
     avlTmm.deleteValue(3, 33);
     expect(avlTmm.get(3)).toEqual([3, 333]);
@@ -20,8 +20,8 @@ describe('AVLTreeMultiMap', () => {
     expect(avlTmm.get(3)).toEqual([333]);
     avlTmm.deleteValue(3, 333);
     expect(avlTmm.get(3)).toBe(undefined);
-    avlTmm.add(3, 3);
-    avlTmm.add([3, [3333, 33333]]);
+    avlTmm.set(3, 3);
+    avlTmm.set([3, [3333, 33333]]);
     expect(avlTmm.get(3)).toEqual([3, 3333, 33333]);
   });
 });
@@ -31,9 +31,9 @@ describe('AVLTreeMultiMap Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>();
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
-    avlTmm.add(null);
+    avlTmm.set(null);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -137,17 +137,17 @@ describe('AVLTreeMultiMap Test', () => {
     const avlTmm = new AVLTreeMultiMap<number, string>([4, 5, [1, ['1']], 2, 3]);
     expect(avlTmm.get(1)).toEqual(['1']);
     expect(avlTmm.getNode(1)?.value).toEqual([]);
-    avlTmm.add(1, 'a');
+    avlTmm.set(1, 'a');
     expect(avlTmm.get(1)).toEqual(['1', 'a']);
-    avlTmm.add([1, ['b']]);
+    avlTmm.set([1, ['b']]);
     expect(avlTmm.getNode(1)?.value).toEqual([]);
     expect(avlTmm.get(1)).toEqual(['1', 'a', 'b']);
     const treeMap = new AVLTreeMultiMap<number>([4, 5, [1, ['1']], 2, 3]);
     expect(treeMap.get(1)).toEqual(['1']);
     expect(treeMap.getNode(1)?.value).toEqual([]);
-    treeMap.add(1, 'a');
+    treeMap.set(1, 'a');
     expect(treeMap.get(1)).toEqual(['1', 'a']);
-    treeMap.add([1, ['b']]);
+    treeMap.set([1, ['b']]);
     expect(treeMap.getNode(1)?.value).toEqual([]);
     expect(treeMap.get(1)).toEqual(['1', 'a', 'b']);
   });
@@ -158,7 +158,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
     const node6 = avlTmm.getNode(6);
 
@@ -269,17 +269,17 @@ describe('AVLTreeMultiMap APIs test', () => {
   });
 
   it('add', () => {
-    avlTmm.add(1);
+    avlTmm.set(1);
     const node2 = new AVLTreeMultiMapNode(2, []);
-    avlTmm.add(node2);
+    avlTmm.set(node2);
     const node3 = new AVLTreeMultiMapNode(3, [
       {
         id: 3,
         text: 'text3'
       }
     ]);
-    avlTmm.add(node3);
-    avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
+    avlTmm.set(node3);
+    avlTmm.set([3, [{ id: 3, text: 'text33' }]]);
 
     const bfsRes = avlTmm.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -298,7 +298,7 @@ describe('AVLTreeMultiMap APIs test', () => {
     }
 
     const avlTmm = new AVLTreeMultiMap<string, number>();
-    avlTmm.addMany([
+    avlTmm.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -326,26 +326,26 @@ describe('AVLTreeMultiMap APIs test', () => {
 describe('AVLTreeMultiMap', () => {
   it('should balance the avlTmm using _balanceLR when nodes are added', () => {
     const avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([10, 'A']);
-    avlTmm.add([5, 'B']);
-    avlTmm.add([15, 'C']);
-    avlTmm.add([3, 'D']);
-    avlTmm.add([7, 'E']);
+    avlTmm.set([10, 'A']);
+    avlTmm.set([5, 'B']);
+    avlTmm.set([15, 'C']);
+    avlTmm.set([3, 'D']);
+    avlTmm.set([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTmm.add([12, 'F']);
+    avlTmm.set([12, 'F']);
 
     // You can add more specific assertions to check the avlTmm's balance and structure.
   });
 
   it('should addMany undefined and null', () => {
     const avlTmm = new AVLTreeMultiMap<number, string>();
-    const addManyWithUndefined = avlTmm.addMany([1, undefined, 3]);
+    const addManyWithUndefined = avlTmm.setMany([1, undefined, 3]);
     expect(addManyWithUndefined).toEqual([true, false, true]);
     expect(avlTmm.get(undefined)).toBe(undefined);
-    const addManyWithNull = avlTmm.addMany([1, null, 3, 4]);
+    const addManyWithNull = avlTmm.setMany([1, null, 3, 4]);
     expect(addManyWithNull).toEqual([true, false, true, true]);
-    const addManyEntriesWithNull = avlTmm.addMany([
+    const addManyEntriesWithNull = avlTmm.setMany([
       [1, '1'],
       [null, 'null'],
       [3, '3'],
@@ -353,19 +353,19 @@ describe('AVLTreeMultiMap', () => {
     ]);
     expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
     expect(avlTmm.get(null)).toBe(undefined);
-    const node0 = avlTmm.add(0, '0');
+    const node0 = avlTmm.set(0, '0');
     expect(node0).toBe(true);
     expect(avlTmm.get(0)).toEqual(['0']);
   });
 
   it('should balance the avlTmm using _balanceLR when nodes are deleted', () => {
     const avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([10, 'A']);
-    avlTmm.add([5, 'B']);
-    avlTmm.add([15, 'C']);
-    avlTmm.add([3, 'D']);
-    avlTmm.add([7, 'E']);
-    avlTmm.add([12, 'F']);
+    avlTmm.set([10, 'A']);
+    avlTmm.set([5, 'B']);
+    avlTmm.set([15, 'C']);
+    avlTmm.set([3, 'D']);
+    avlTmm.set([7, 'E']);
+    avlTmm.set([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTmm.delete(3);
@@ -380,17 +380,17 @@ describe('AVLTreeMultiMap', () => {
     });
 
     it('add', () => {
-      avlTmm.add(1);
+      avlTmm.set(1);
       const node2 = new AVLTreeMultiMapNode(2, []);
-      avlTmm.add(node2);
+      avlTmm.set(node2);
       const node3 = new AVLTreeMultiMapNode(3, [
         {
           id: 3,
           text: 'text3'
         }
       ]);
-      avlTmm.add(node3);
-      avlTmm.add([3, [{ id: 3, text: 'text33' }]]);
+      avlTmm.set(node3);
+      avlTmm.set([3, [{ id: 3, text: 'text33' }]]);
 
       const bfsRes = avlTmm.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -402,9 +402,9 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   let avlTmm: AVLTreeMultiMap<number, string, object>;
   beforeEach(() => {
     avlTmm = new AVLTreeMultiMap();
-    avlTmm.add([1, ['a']]);
-    avlTmm.add([2, ['b']]);
-    avlTmm.add([3, ['c']]);
+    avlTmm.set([1, ['a']]);
+    avlTmm.set([2, ['b']]);
+    avlTmm.set([3, ['c']]);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -490,9 +490,9 @@ describe('AVLTreeMultiMap not map mode', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([]);
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
 
-    avlTmm.add(null);
+    avlTmm.set(null);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -526,7 +526,7 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTmm.add([i, [i]]);
+    for (const i of arr) avlTmm.set([i, [i]]);
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -559,9 +559,9 @@ describe('AVLTreeMultiMap iterative methods not map mode', () => {
   let avlTmm: AVLTreeMultiMap<number, string>;
   beforeEach(() => {
     avlTmm = new AVLTreeMultiMap<number, string>([]);
-    avlTmm.add([1, ['a']]);
-    avlTmm.add([2, ['b']]);
-    avlTmm.add([3, ['c']]);
+    avlTmm.set([1, ['a']]);
+    avlTmm.set([2, ['b']]);
+    avlTmm.set([3, ['c']]);
   });
 
   it('should clone work well', () => {

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

@@ -5,9 +5,9 @@ describe('AVL Tree Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>();
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
-    avlTree.add(null);
+    avlTree.set(null);
     const node6 = avlTree.getNode(6);
 
     expect(node6 && avlTree.getHeight(node6)).toBe(3);
@@ -111,17 +111,17 @@ describe('AVL Tree Test', () => {
     const avlTree = new AVLTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
     expect(avlTree.get(1)).toBe('1');
     expect(avlTree.getNode(1)?.value).toBe('1');
-    avlTree.add(1, 'a');
+    avlTree.set(1, 'a');
     expect(avlTree.get(1)).toBe('a');
-    avlTree.add([1, 'b']);
+    avlTree.set([1, 'b']);
     expect(avlTree.getNode(1)?.value).toBe('b');
     expect(avlTree.get(1)).toBe('b');
     const treeMap = new AVLTree<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');
   });
@@ -132,7 +132,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 avlTree = new AVLTree<number>([], { iterationType: 'RECURSIVE' });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
     const node6 = avlTree.getNode(6);
 
@@ -243,15 +243,15 @@ describe('AVLTree APIs test', () => {
   });
 
   it('add', () => {
-    avlTree.add(1);
+    avlTree.set(1);
     const node2 = new AVLTreeNode(2);
-    avlTree.add(node2);
+    avlTree.set(node2);
     const node3 = new AVLTreeNode(3, {
       id: 3,
       text: 'text3'
     });
-    avlTree.add(node3);
-    avlTree.add([3, { id: 3, text: 'text33' }]);
+    avlTree.set(node3);
+    avlTree.set([3, { id: 3, text: 'text33' }]);
 
     const bfsRes = avlTree.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -270,7 +270,7 @@ describe('AVLTree APIs test', () => {
     }
 
     const avlTree = new AVLTree<string, number>();
-    avlTree.addMany([
+    avlTree.setMany([
       ['2', 2],
       ['4', 4],
       ['5', 5],
@@ -298,26 +298,26 @@ describe('AVLTree APIs test', () => {
 describe('AVLTree', () => {
   it('should balance the avlTree 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.set([10, 'A']);
+    avlTree.set([5, 'B']);
+    avlTree.set([15, 'C']);
+    avlTree.set([3, 'D']);
+    avlTree.set([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTree.add([12, 'F']);
+    avlTree.set([12, 'F']);
 
     // You can add more specific assertions to check the avlTree's balance and structure.
   });
 
   it('should addMany undefined and null', () => {
     const avlTree = new AVLTree<number, string>();
-    const addManyWithUndefined = avlTree.addMany([1, undefined, 3]);
+    const addManyWithUndefined = avlTree.setMany([1, undefined, 3]);
     expect(addManyWithUndefined).toEqual([true, false, true]);
     expect(avlTree.get(undefined)).toBe(undefined);
-    const addManyWithNull = avlTree.addMany([1, null, 3, 4]);
+    const addManyWithNull = avlTree.setMany([1, null, 3, 4]);
     expect(addManyWithNull).toEqual([true, false, true, true]);
-    const addManyEntriesWithNull = avlTree.addMany([
+    const addManyEntriesWithNull = avlTree.setMany([
       [1, '1'],
       [null, 'null'],
       [3, '3'],
@@ -325,19 +325,19 @@ describe('AVLTree', () => {
     ]);
     expect(addManyEntriesWithNull).toEqual([true, false, true, true]);
     expect(avlTree.get(null)).toBe(undefined);
-    const node0 = avlTree.add(0, '0');
+    const node0 = avlTree.set(0, '0');
     expect(node0).toBe(true);
     expect(avlTree.get(0)).toBe('0');
   });
 
   it('should balance the avlTree 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.set([10, 'A']);
+    avlTree.set([5, 'B']);
+    avlTree.set([15, 'C']);
+    avlTree.set([3, 'D']);
+    avlTree.set([7, 'E']);
+    avlTree.set([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTree.delete(3);
@@ -352,15 +352,15 @@ describe('AVLTree', () => {
     });
 
     it('add', () => {
-      avlTree.add(1);
+      avlTree.set(1);
       const node2 = new AVLTreeNode(2);
-      avlTree.add(node2);
+      avlTree.set(node2);
       const node3 = new AVLTreeNode(3, {
         id: 3,
         text: 'text3'
       });
-      avlTree.add(node3);
-      avlTree.add([3, { id: 3, text: 'text33' }]);
+      avlTree.set(node3);
+      avlTree.set([3, { id: 3, text: 'text33' }]);
 
       const bfsRes = avlTree.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -372,9 +372,9 @@ describe('AVLTree iterative methods test', () => {
   let avlTree: AVLTree<number, string>;
   beforeEach(() => {
     avlTree = new AVLTree();
-    avlTree.add([1, 'a']);
-    avlTree.add([2, 'b']);
-    avlTree.add([3, 'c']);
+    avlTree.set([1, 'a']);
+    avlTree.set([2, 'b']);
+    avlTree.set([3, 'c']);
   });
 
   it('The node obtained by get Node should match the node type', () => {
@@ -461,9 +461,9 @@ describe('AVL Tree not map mode', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>([], { isMapMode: false });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
-    avlTree.add(null);
+    avlTree.set(null);
     const node6 = avlTree.getNode(6);
 
     expect(node6 && avlTree.getHeight(node6)).toBe(3);
@@ -497,7 +497,7 @@ describe('AVL Tree not map mode test recursively', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const avlTree = new AVLTree<number>([], { iterationType: 'RECURSIVE', isMapMode: false });
 
-    for (const i of arr) avlTree.add([i, i]);
+    for (const i of arr) avlTree.set([i, i]);
 
     const node6 = avlTree.getNode(6);
 
@@ -531,9 +531,9 @@ describe('AVLTree iterative methods not map mode', () => {
   let avlTree: AVLTree<number, string>;
   beforeEach(() => {
     avlTree = new AVLTree<number, string>([], { isMapMode: false });
-    avlTree.add([1, 'a']);
-    avlTree.add([2, 'b']);
-    avlTree.add([3, 'c']);
+    avlTree.set([1, 'a']);
+    avlTree.set([2, 'b']);
+    avlTree.set([3, 'c']);
   });
 
   it('should clone work well', () => {
@@ -562,7 +562,7 @@ describe('classic use', () => {
     expect(tree.size).toBe(5);
 
     // Add a new element
-    tree.add(3);
+    tree.set(3);
     expect(tree.size).toBe(6);
     expect([...tree.keys()]).toEqual([1, 2, 3, 5, 8, 9]);
   });
@@ -628,7 +628,7 @@ describe('classic use', () => {
     expect(universityTree.isAVLBalanced()).toBe(true);
 
     // Add more universities
-    universityTree.add(6, { name: 'Oxford', rank: 6, students: 2000 });
+    universityTree.set(6, { name: 'Oxford', rank: 6, students: 2000 });
     expect(universityTree.isAVLBalanced()).toBe(true);
 
     // Delete and verify balance is maintained