data-structure-typed 1.53.0 → 1.53.1

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

@@ -182,6 +182,25 @@ describe('RedBlackTree 1', () => {
     expect(rbTree.size).toBe(4);
     expect(cloned.size).toBe(3);
   });
+
+  it('should replace value', () => {
+    const tree = new RedBlackTree<number, string>([4, 5, [1, '1'], 2, 3], { isMapMode: false });
+    expect(tree.get(1)).toBe('1');
+    expect(tree.getNode(1)?.value).toBe('1');
+    tree.add(1, 'a');
+    expect(tree.get(1)).toBe('a');
+    tree.add([1, 'b']);
+    expect(tree.getNode(1)?.value).toBe('b');
+    expect(tree.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');
+    expect(treeMap.get(1)).toBe('a');
+    treeMap.add([1, 'b']);
+    expect(treeMap.getNode(1)?.value).toBe(undefined);
+    expect(treeMap.get(1)).toBe('b');
+  });
 });
 
 describe('RedBlackTree 2', () => {

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

@@ -133,7 +133,7 @@ describe('TreeMultiMap operations test1', () => {
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(node => node.value === 9);
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = tmm.getNodes(node => node.count === 1);
@@ -391,7 +391,7 @@ describe('TreeMultiMap operations test recursively1', () => {
     const nodeId10 = tmm.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = tmm.getNode(node => node.value === 9);
+    const nodeVal9 = tmm.getNode(node => node.key === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const nodesByCount1 = tmm.getNodes(node => node.count === 1);
@@ -837,10 +837,10 @@ describe('TreeMultiMap iterative methods test', () => {
   });
 });
 
-describe('TreeMultiMap count map mode', () => {
+describe('TreeMultiMap count not map mode', () => {
   let tmm: TreeMultiMap<number>;
   beforeEach(() => {
-    tmm = new TreeMultiMap<number>([], { isMapMode: true });
+    tmm = new TreeMultiMap<number>([], { isMapMode: false });
   });
 
   it('Should added node count ', () => {
@@ -860,9 +860,9 @@ describe('TreeMultiMap count map mode', () => {
   });
 });
 
-describe('TreeMultiMap operations test1 map mode', () => {
+describe('TreeMultiMap operations test1 not map mode', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
-    const tmm = new TreeMultiMap<number, number>([], { isMapMode: true });
+    const tmm = new TreeMultiMap<number, number>([], { isMapMode: false });
 
     expect(tmm instanceof TreeMultiMap);
 
@@ -907,11 +907,11 @@ describe('TreeMultiMap operations test1 map mode', () => {
   });
 });
 
-describe('TreeMultiMap operations test recursively1 map mode', () => {
+describe('TreeMultiMap operations test recursively1 not map mode', () => {
   it('should perform various operations on a Binary Search Tree with numeric values1', () => {
     const tmm = new TreeMultiMap<number>([], {
       iterationType: 'RECURSIVE',
-      isMapMode: true
+      isMapMode: false
     });
 
     expect(tmm instanceof TreeMultiMap);
@@ -956,10 +956,10 @@ describe('TreeMultiMap operations test recursively1 map mode', () => {
   });
 });
 
-describe('TreeMultiMap iterative methods testm ap mode', () => {
+describe('TreeMultiMap iterative methods test not map mode', () => {
   let treeMM: TreeMultiMap<number, string>;
   beforeEach(() => {
-    treeMM = new TreeMultiMap<number, string>([], { isMapMode: true });
+    treeMM = new TreeMultiMap<number, string>([], { isMapMode: false });
     treeMM.add(1, 'a', 10);
     treeMM.add([2, 'b'], undefined, 10);
     treeMM.add([3, 'c'], undefined, 1);
@@ -970,6 +970,6 @@ describe('TreeMultiMap iterative methods testm ap mode', () => {
     expect(treeMM.getComputedCount()).toBe(21);
     const cloned = treeMM.clone();
     expect(cloned.root?.left?.key).toBe(1);
-    expect(cloned.get(cloned.root?.right)).toBe('c');
+    expect(cloned.get(cloned.root?.right)).toBe(undefined);
   });
 });

package/test/utils/array.ts

@@ -1,19 +1,22 @@
 import { getRandomInt } from './number';
 
-export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, isDistinct = true) {
-  if (isDistinct) {
-    const set = new Set<number>();
-    const ans: number[] = [];
-    while (ans.length < length) {
-      const num = getRandomInt(min, max);
-      if (!set.has(num)) {
-        ans.push(num);
-        set.add(num);
-      }
+export function getRandomIntArray(length: number = 1000, min: number = -1000, max: number = 1000, unique = true) {
+  if (unique) {
+    if (max - min + 1 < length) {
+      throw new Error("Range too small for unique values with the specified length");
     }
-    return ans;
+
+    const allNumbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
+
+    for (let i = allNumbers.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
+    }
+
+    return allNumbers.slice(0, length);
+  } else {
+    return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min);
   }
-  return new Array<number>(length).fill(0).map(() => getRandomInt(min, max));
 }
 
 const words = [