data-structure-typed 1.52.5 → 1.52.7

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

@@ -69,7 +69,7 @@ describe('BST operations test', () => {
     const nodeId10 = bst.getNode(10);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(9, node => node.value);
+    const nodeVal9 = bst.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(9);
 
     const leftMost = bst.getLeftMost();
@@ -81,8 +81,11 @@ describe('BST operations test', () => {
     const minNodeBySpecificNode = node15 && bst.getLeftMost(node => node, node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
+    const nodes = bst.getNodes(node => node.value === 15);
+    expect(nodes.map(node => node.key)).toEqual([15]);
+
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -231,6 +234,9 @@ describe('BST operations test', () => {
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
     expect(bfsNodes[2].key).toBe(16);
+    bst.clear();
+    expect(bst.perfectlyBalance()).toBe(false);
+    expect(bst.isAVLBalanced()).toBe(true);
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
@@ -288,7 +294,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -484,7 +490,7 @@ describe('BST operations test recursively', () => {
     expect(bst.get(10)).toBe(undefined);
     expect(nodeId10?.key).toBe(10);
 
-    const nodeVal9 = bst.getNode(9, node => node.value);
+    const nodeVal9 = bst.getNode(node => node.value === 9);
     expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
@@ -495,7 +501,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) bst.dfs(node => (subTreeSum += node.key), 'PRE', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -702,7 +708,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) objBST.dfs(node => (subTreeSum += node.key), 'PRE', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -869,6 +875,28 @@ describe('BST operations test recursively', () => {
     expect(numBST.size).toBe(0);
   });
 
+  it('should listLevels', () => {
+    const bst = new BST<number>();
+    bst.addMany([2, 4, 5, 3, 1]);
+    expect(bst.size).toBe(5);
+    bst.delete(1);
+    bst.delete(5);
+    const levelKeys = bst.listLevels();
+    expect(levelKeys).toEqual([[3], [2, 4]]);
+  });
+
+  it('should lesserOrGreaterTraverse', () => {
+    const bst = new BST<number>();
+    const levelKeys = bst.lesserOrGreaterTraverse();
+    expect(levelKeys).toEqual([]);
+    bst.addMany([2, 4, 5, 3, 1]);
+    expect(bst.size).toBe(5);
+    bst.delete(1);
+    bst.delete(5);
+    const levelKeys1 = bst.lesserOrGreaterTraverse();
+    expect(levelKeys1).toEqual([2]);
+  });
+
   it('should the clone method', () => {
     function checkTreeStructure(bst: BST<string, number>) {
       expect(bst.size).toBe(4);
@@ -972,7 +1000,7 @@ describe('BST Performance test', function () {
   it(`Observe the time consumption of BST.dfs be good`, function () {
     const startDFS = performance.now();
     const dfs = bst.dfs(node => node);
-    isDebug && console.log('---bfs', performance.now() - startDFS, dfs.length);
+    if (isDebug) console.log('---bfs', performance.now() - startDFS, dfs.length);
   });
 
   it('Should the time consumption of lesserOrGreaterTraverse fitting O(n log n)', function () {
@@ -982,16 +1010,16 @@ describe('BST Performance test', function () {
     }
     const start = performance.now();
     bst.addMany(nodes);
-    isDebug && console.log('---add', performance.now() - start);
+    if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
     bst.lesserOrGreaterTraverse(
       node => {
-        node.key - 1;
+        node.key -= 1;
       },
       -1,
       inputSize / 2
     );
-    isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
+    if (isDebug) console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 
   it('Should the time consumption of listLevels fitting well', function () {
@@ -1001,11 +1029,11 @@ describe('BST Performance test', function () {
     }
     const start = performance.now();
     bst.addMany(nodes);
-    isDebug && console.log('---add', performance.now() - start);
+    if (isDebug) console.log('---add', performance.now() - start);
     const startL = performance.now();
     const arr: number[][] = bst.listLevels(node => node.key);
-    isDebug && console.log('---listLevels', arr);
-    isDebug && console.log('---listLevels', performance.now() - startL);
+    if (isDebug) console.log('---listLevels', arr);
+    if (isDebug) console.log('---listLevels', performance.now() - startL);
   });
 
   it('should the lastKey of a BST to be the largest key', function () {

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

@@ -6,18 +6,13 @@ describe('Overall BinaryTree Test', () => {
     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.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true
     expect(bst.has(6)).toBe(true); // true
-    bst.getHeight(6) === 2; // true
-    bst.getHeight() === 5; // true
-    bst.getDepth(6) === 3; // true
     expect(bst.getHeight(6)).toBe(2); // true
     expect(bst.getHeight()).toBe(5); // true
     expect(bst.getDepth(6)).toBe(3); // true
     const leftMost = bst.getLeftMost();
-    leftMost?.key === 1; // true
     expect(leftMost).toBe(1);
     bst.delete(6);
     bst.getNode(6); // undefined
@@ -26,7 +21,6 @@ describe('Overall BinaryTree Test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     const bfsIDs: number[] = [];
     bst.bfs(node => bfsIDs.push(node.key));
-    bfsIDs[0] === 11; // true
     expect(bfsIDs[0]).toBe(11);
 
     const objBST = new BST<number, { key: number; keyA: number }>();

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

@@ -414,7 +414,7 @@ describe('RedBlackTree 2', () => {
     expect(node225F?.right).toBe(rbTree.NIL);
     expect(node225F?.parent?.key).toBe(155);
     rbTree.add(7);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     const node15S = rbTree.getNode(15);
     expect(node15S?.left?.key).toBe(10);
@@ -463,7 +463,7 @@ describe('RedBlackTree 2', () => {
     rbTree.add(19);
     rbTree.add(110);
 
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     expect(rbTree.dfs()).toEqual([
       1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 22, 23, 25, 28, 33, 50, 110, 111, 155, 225
@@ -525,19 +525,19 @@ describe('RedBlackTree 2', () => {
     for (let i = 0; i < arr.length; i++) {
       rbTree.add(arr[i]);
     }
-    isDebug && console.log(performance.now() - tS);
+    if (isDebug) console.log(performance.now() - tS);
 
     const cS = performance.now();
 
     for (let i = 0; i < arr.length; i++) {
       competitor.setElement(arr[i], arr[i]);
     }
-    isDebug && console.log(performance.now() - cS);
+    if (isDebug) console.log(performance.now() - cS);
   });
 
   it('duplicates', () => {
     rbTree.addMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
-    isDebug && rbTree.print();
+    if (isDebug) rbTree.print();
 
     expect(rbTree.size).toBe(8);
     expect(rbTree.isBST()).toBe(true);
@@ -606,7 +606,7 @@ describe('RedBlackTree 2', () => {
       expect(rbTree.getHeight()).toBe(-1);
       expect(nanCount).toBeLessThanOrEqual(inputSize);
 
-      isDebug && rbTree.print();
+      if (isDebug) rbTree.print();
     });
   });
 

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

@@ -1,50 +1,104 @@
-import { SegmentTree } from '../../../../src';
+import { SegmentTree, SegmentTreeNode } from '../../../../src';
 
-describe('SegmentTree', () => {
-  let segmentTree: SegmentTree;
-
-  beforeEach(() => {
-    // Create an example SegmentTree for testing
-    const values = [1, 2, 3, 4, 5];
-    segmentTree = new SegmentTree(values);
+describe('SegmentTreeNode', () => {
+  it('should initialize with correct start, end, sum, and optional value', () => {
+    const node = new SegmentTreeNode(0, 1, 10, 2);
+    expect(node.start).toBe(0);
+    expect(node.end).toBe(1);
+    expect(node.sum).toBe(10);
+    expect(node.value).toBe(2);
   });
 
-  it('should build a valid segment tree', () => {
-    // Check if the root node's sum is correct
-    expect(segmentTree.root?.sum).toBe(15);
+  it('should allow setting start, end, sum, value, left, and right', () => {
+    const node = new SegmentTreeNode(0, 1, 10);
+    node.start = 2;
+    node.end = 3;
+    node.sum = 15;
+    node.value = 2;
+
+    const leftNode = new SegmentTreeNode(0, 1, 5);
+    const rightNode = new SegmentTreeNode(2, 3, 10);
+
+    node.left = leftNode;
+    node.right = rightNode;
+
+    expect(node.start).toBe(2);
+    expect(node.end).toBe(3);
+    expect(node.sum).toBe(15);
+    expect(node.value).toBe(2);
+    expect(node.left).toBe(leftNode);
+    expect(node.right).toBe(rightNode);
   });
+});
 
-  it('should update a node in the segment tree', () => {
-    // Update a node value
-    segmentTree.updateNode(2, 10);
+describe('SegmentTree', () => {
+  it('should initialize with correct values, start, end, and root', () => {
+    const values = [1, 2, 3, 4];
+    const tree = new SegmentTree(values);
 
-    // Check if the sum of the root node is correct after the update
-    expect(segmentTree.root?.sum).toBe(22);
+    expect(tree.values).toEqual(values);
+    expect(tree.start).toBe(0);
+    expect(tree.end).toBe(3);
+    expect(tree.root).toBeDefined();
   });
 
-  it('should query sum by range correctly', () => {
-    // Check if the sum within a specific range is correct
-    expect(segmentTree.querySumByRange(1, 3)).toBe(9); // 2 + 3 + 4 = 9
+  it('should correctly build segment tree with sum of values', () => {
+    const values = [1, 2, 3, 4];
+    const tree = new SegmentTree(values);
+
+    expect(tree.root?.sum).toBe(10); // 1 + 2 + 3 + 4
   });
 
-  it('should handle edge cases for querySumByRange', () => {
-    // Check behavior when the range goes beyond boundaries
-    expect(segmentTree.querySumByRange(0, 4)).toBe(15); // Valid range, should return sum of the specified range
-    expect(segmentTree.querySumByRange(3, 2)).toBe(NaN); // End index is less than start index, should return NaN
-    expect(segmentTree.querySumByRange(0, 10)).toBe(NaN); // Beyond upper bound, should return NaN
+  it('should handle empty values array gracefully', () => {
+    const tree = new SegmentTree([]);
+    expect(tree.values).toEqual([]);
+    expect(tree.root).toBeUndefined();
   });
 
-  it('should handle an empty input array', () => {
-    // Check behavior when dealing with an empty input array
-    const emptySegmentTree = new SegmentTree([]);
-    expect(emptySegmentTree.root).toBe(undefined);
-    expect(emptySegmentTree.querySumByRange(0, 2)).toBe(0); // Sum of an empty array should be 0
+  describe('updateNode', () => {
+    it('should update node value and sum correctly', () => {
+      const values = [1, 2, 3, 4];
+      const tree = new SegmentTree(values);
+      tree.updateNode(1, 5, 2);
+
+      expect(tree.root?.sum).toBe(13); // 1 + 5 + 3 + 4
+      expect(tree.root?.left?.right?.sum).toBe(5);
+      expect(tree.root?.left?.right?.value).toBe(2);
+    });
+
+    it('should do nothing if root is undefined', () => {
+      const tree = new SegmentTree([]);
+      tree.updateNode(0, 10);
+      expect(tree.root).toBeUndefined();
+    });
   });
 
-  it('should handle a single-element input array', () => {
-    // Check behavior when the input array contains a single element
-    const singleElementSegmentTree = new SegmentTree([42]);
-    expect(singleElementSegmentTree.root?.sum).toBe(42);
-    expect(singleElementSegmentTree.querySumByRange(0, 0)).toBe(42); // Range covering the only element should return that element's value
+  describe('querySumByRange', () => {
+    it('should return sum for a given range', () => {
+      const values = [1, 2, 3, 4, 5];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(1, 3); // 2 + 3 + 4 = 9
+      expect(result).toBe(9);
+    });
+
+    it('should return NaN for an invalid range', () => {
+      const values = [1, 2, 3, 4, 5];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(3, 1); // Invalid range
+      expect(result).toBeNaN();
+    });
+
+    it('should return 0 if root is undefined', () => {
+      const tree = new SegmentTree([]);
+      const result = tree.querySumByRange(0, 1);
+      expect(result).toBe(0);
+    });
+
+    it('should return NaN if range is out of bounds', () => {
+      const values = [1, 2, 3, 4];
+      const tree = new SegmentTree(values);
+      const result = tree.querySumByRange(-1, 10);
+      expect(result).toBeNaN();
+    });
   });
 });