data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -1,9 +1,9 @@
-import {AVLTree} from '../../../../src';
+import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree();
+    const tree = new AVLTree<number>();
 
     for (const i of arr) tree.add(i, i);
 
@@ -12,7 +12,7 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10, 'key');
+    const getNodeById = tree.get(10);
     expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
@@ -22,75 +22,77 @@ describe('AVL Tree Test', () => {
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
-    const subTreeSum = node15 && tree.subTreeSum(node15);
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
     expect(subTreeSum).toBe(70);
 
-    const lesserSum = tree.lesserSum(10);
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
     expect(lesserSum).toBe(45);
 
     // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
-    expect(node15?.val).toBe(15);
+    expect(node15?.value).toBe(15);
 
-    const dfs = tree.dfs('in', 'node');
+    const dfs = tree.dfs(node => node, 'in');
     expect(dfs[0].key).toBe(1);
     expect(dfs[dfs.length - 1].key).toBe(16);
 
     tree.perfectlyBalance();
-    const bfs = tree.bfs('node');
+    const bfs = tree.bfs(node => node);
     expect(tree.isPerfectlyBalanced()).toBe(true);
     expect(bfs[0].key).toBe(8);
     expect(bfs[bfs.length - 1].key).toBe(16);
 
-    expect(tree.remove(11)[0].deleted?.key).toBe(11);
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 
-    expect(tree.remove(1)[0].deleted?.key).toBe(1);
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(4)[0].deleted?.key).toBe(4);
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(10)[0].deleted?.key).toBe(10);
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(15)[0].deleted?.key).toBe(15);
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
     expect(tree.isAVLBalanced()).toBe(true);
 
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(5)[0].deleted?.key).toBe(5);
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(13)[0].deleted?.key).toBe(13);
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(3)[0].deleted?.key).toBe(3);
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(8)[0].deleted?.key).toBe(8);
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(6)[0].deleted?.key).toBe(6);
-    expect(tree.remove(6).length).toBe(0);
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(7)[0].deleted?.key).toBe(7);
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(9)[0].deleted?.key).toBe(9);
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
-    expect(tree.remove(14)[0].deleted?.key).toBe(14);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(1);
 
@@ -100,9 +102,168 @@ describe('AVL Tree Test', () => {
     expect(lastBFSIds[1]).toBe(2);
     expect(lastBFSIds[2]).toBe(16);
 
-    const lastBFSNodes = tree.bfs('node');
+    const lastBFSNodes = tree.bfs(node => node);
     expect(lastBFSNodes[0].key).toBe(12);
     expect(lastBFSNodes[1].key).toBe(2);
     expect(lastBFSNodes[2].key).toBe(16);
   });
 });
+
+describe('AVL Tree Test recursively', () => {
+  it('should perform various operations on a AVL Tree', () => {
+    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);
+
+    const node6 = tree.get(6);
+
+    expect(node6 && tree.getHeight(node6)).toBe(3);
+    expect(node6 && tree.getDepth(node6)).toBe(1);
+
+    const getNodeById = tree.get(10);
+    expect(getNodeById?.key).toBe(10);
+
+    const getMinNodeByRoot = tree.getLeftMost();
+    expect(getMinNodeByRoot?.key).toBe(1);
+
+    const node15 = tree.get(15);
+    const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
+
+    let subTreeSum = 0;
+    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    expect(subTreeSum).toBe(70);
+
+    let lesserSum = 0;
+    tree.lesserOrGreaterTraverse(node => (lesserSum += node.key), CP.lt, 10);
+    expect(lesserSum).toBe(45);
+
+    // node15 has type problem. After the uniform design, the generics of containers (DirectedGraph, BST) are based on the type of value. However, this design has a drawback: when I attempt to inherit from the Vertex or BSTNode classes, the types of the results obtained by all methods are those of the parent class.
+    expect(node15?.value).toBe(15);
+
+    const dfs = tree.dfs(node => node, 'in');
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
+
+    tree.perfectlyBalance();
+    const bfs = tree.bfs(node => node);
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
+
+    expect(tree.delete(11)[0].deleted?.key).toBe(11);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(node15 && tree.getHeight(node15)).toBe(2);
+
+    expect(tree.delete(1)[0].deleted?.key).toBe(1);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(4)[0].deleted?.key).toBe(4);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(4);
+
+    expect(tree.delete(10)[0].deleted?.key).toBe(10);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(15)[0].deleted?.key).toBe(15);
+    expect(tree.isAVLBalanced()).toBe(true);
+
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(5)[0].deleted?.key).toBe(5);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(13)[0].deleted?.key).toBe(13);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(3)[0].deleted?.key).toBe(3);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(8)[0].deleted?.key).toBe(8);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(3);
+
+    expect(tree.delete(6)[0].deleted?.key).toBe(6);
+    expect(tree.delete(6).length).toBe(0);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(7)[0].deleted?.key).toBe(7);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+
+    expect(tree.delete(9)[0].deleted?.key).toBe(9);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(2);
+    expect(tree.delete(14)[0].deleted?.key).toBe(14);
+    expect(tree.isAVLBalanced()).toBe(true);
+    expect(tree.getHeight()).toBe(1);
+
+    expect(tree.isAVLBalanced()).toBe(true);
+    const lastBFSIds = tree.bfs();
+    expect(lastBFSIds[0]).toBe(12);
+    expect(lastBFSIds[1]).toBe(2);
+    expect(lastBFSIds[2]).toBe(16);
+
+    const lastBFSNodes = tree.bfs(node => node);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
+  });
+});
+
+describe('AVLTree APIs test', () => {
+  const avl = new AVLTree<{id: number; text: string}>();
+  beforeEach(() => {
+    avl.clear();
+  });
+
+  it('add', () => {
+    avl.add(1);
+    const node2 = new AVLTreeNode(2);
+    avl.add(node2);
+    const node3 = new AVLTreeNode(3, {id: 3, text: 'text3'});
+    avl.add(node3);
+    avl.add(node3, {id: 3, text: 'text33'});
+
+    const bfsRes = avl.bfs(node => node.key);
+    expect(bfsRes[0]).toBe(2);
+  });
+});
+
+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');
+
+    // Adding nodes to trigger _balanceLR
+    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');
+
+    // Deleting nodes to trigger _balanceLR
+    avlTree.delete(3);
+
+    // You can add more specific assertions to check the tree's balance and structure.
+  });
+});

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

@@ -0,0 +1,320 @@
+import {BinaryIndexedTree} from '../../../../src';
+// import {isDebugTest} from '../../../config';
+
+// const isDebug = isDebugTest;
+
+describe('BinaryIndexedTree simple', () => {
+  let bit: BinaryIndexedTree;
+
+  beforeEach(() => {
+    //Create a new BinaryIndexedTree instance before each test case
+    bit = new BinaryIndexedTree({frequency: 0, max: 10}); // Modify the value of max as needed
+  });
+
+  it('should initialize correctly', () => {
+    expect(bit.freq).toBe(0);
+    expect(bit.max).toBe(10);
+    expect(bit.freqMap).toEqual({0: 0}); // Modify the initialized record value according to the actual situation
+    // More initialization checks can be added
+  });
+
+  it('should read a single value correctly', () => {
+    // Test the function of reading a single value
+    bit.writeSingle(5, 5); //Write test data
+    expect(bit.readSingle(5)).toBe(5); // Read and verify
+  });
+
+  it('should update a value correctly', () => {
+    // Test the ability to update a single value
+    bit.writeSingle(5, 5); //Write test data
+    bit.update(5, 2); // update value
+    expect(bit.readSingle(5)).toBe(7); // Verify the updated value
+  });
+
+  it('should find lower bound correctly', () => {
+    //Test the function of finding the lower bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.lowerBound(15)).toBe(5); // Find and verify the lower bound
+  });
+
+  it('should find upper bound correctly', () => {
+    //Test the function of finding the upper bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.upperBound(25)).toBe(5); // Find and verify the upper bound
+  });
+});
+
+describe('BinaryIndexedTree', () => {
+  const frequency = 999;
+  const max = 10;
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({frequency, max});
+  });
+  it('should validate the index', function () {
+    expect(() => bit.readSingle(-1)).toThrow('Index out of range');
+    expect(() => bit.readSingle(10)).toThrow('Index out of range');
+  });
+
+  it('should read a single frequency correctly', function () {
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.update(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.update(10, 100)).toThrow('Index out of range');
+  });
+  it('should frequency and max', function () {
+    const frequency = 200;
+    const max = 1000;
+    const bit = new BinaryIndexedTree({frequency, max});
+
+    expect(bit.freq).toBe(frequency);
+    expect(bit.max).toBe(max);
+  });
+
+  it('should update the frequency with the given delta', function () {
+    for (let i = 0; i < max; i++) {
+      bit.update(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2 + frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.writeSingle(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.writeSingle(10, 100)).toThrow('Index out of range');
+  });
+
+  it('should writeSingle to be correctly invoked', function () {
+    for (let i = 0; i < max; i++) {
+      bit.writeSingle(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2);
+    }
+  });
+
+  it('should read the frequency', function () {
+    for (let c = 0; c <= max; c++) {
+      expect(bit.read(c)).toBe(c * frequency);
+    }
+  });
+
+  const values = [-5, 0, 5, 10, 95, 100, 1000];
+  it('should find the upper-bound index', function () {
+    loopUpperBoundTests(bit, values);
+  });
+
+  it('should find the lower-bound index', function () {
+    loopLowerBoundTests(bit, values);
+  });
+});
+
+describe('designated values', function () {
+  const array = [1, 8, 6, 10, 7, 9, 0, 2, 6, 3];
+  const sumArray = (sum => array.map(value => (sum += value)))(0);
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  describe('readSingle', function () {
+    it('should read a single frequency correctly', function () {
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i]);
+      });
+    });
+  });
+
+  describe('update', function () {
+    it('should update the frequency with the given delta', function () {
+      array.forEach((value, i) => bit.update(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] * 2 + i);
+      });
+    });
+  });
+
+  describe('writeSingle', function () {
+    it('should write a single frequency correctly', function () {
+      array.forEach((value, i) => bit.writeSingle(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] + i);
+      });
+    });
+  });
+
+  describe('read', function () {
+    it('should read the cumulative frequency correctly', function () {
+      expect(bit.read(0)).toBe(0);
+      sumArray.forEach((sum, i) => {
+        expect(bit.read(i + 1)).toBe(sum);
+      });
+    });
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should find the upper-bound index', function () {
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('lowerBound', function () {
+    it('should find the lower-bound index', function () {
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('descending sequence', function () {
+  const array = [1, 8, -6, 10, 7, 9, 0, -2, 6, 3];
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  it('should have a correct negativeCount property', function () {
+    expect(bit.negativeCount).toBe(2);
+    bit.update(2, 6);
+    expect(bit.negativeCount).toBe(1);
+    bit.update(7, 3);
+    expect(bit.negativeCount).toBe(0);
+    bit.update(8, -7);
+    expect(bit.negativeCount).toBe(1);
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.upperBound(20)).toThrow('Must not be descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('BinaryIndexedTree lowerBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.lowerBound(20)).toThrow('Sequence is not non-descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('BinaryIndexedTree additional tests', () => {
+  it('should handle read method correctly', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.read(5)).toBe(10); // Ensure read method accumulates correctly
+  });
+
+  it('should handle consecutive operations', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.update(2, 5);
+    expect(bit.readSingle(2)).toBe(15);
+    bit.writeSingle(5, 20);
+    expect(bit.readSingle(5)).toBe(20);
+    expect(bit.lowerBound(15)).toBe(2);
+  });
+
+  it('should handle frequent increment updates', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    for (let i = 0; i < 10; i++) {
+      bit.update(2, 5);
+    }
+    expect(bit.readSingle(2)).toBe(50);
+  });
+
+  it('should handle edge cases', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(9, 100);
+    expect(bit.readSingle(9)).toBe(100);
+    expect(bit.lowerBound(200)).toBe(10);
+  });
+});
+
+function loopUpperBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.upperBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThanOrEqual(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThan(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}
+
+function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.lowerBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThan(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThanOrEqual(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}
+
+describe('', () => {
+  class NumArrayDC {
+    protected _tree: BinaryIndexedTree;
+    protected readonly _nums: number[];
+
+    constructor(nums: number[]) {
+      this._nums = nums;
+      this._tree = new BinaryIndexedTree({max: nums.length + 1});
+      for (let i = 0; i < nums.length; i++) {
+        this._tree.update(i + 1, nums[i]);
+      }
+    }
+
+    update(index: number, value: number): void {
+      this._tree.update(index + 1, value - this._nums[index]);
+      this._nums[index] = value;
+    }
+
+    sumRange(left: number, right: number): number {
+      return this._tree.getPrefixSum(right + 1) - this._tree.getPrefixSum(left);
+    }
+  }
+
+  it('', () => {
+    const numArray = new NumArrayDC([1, 3, 5, 8, 2, 9, 4, 5, 8, 1, 3, 2]);
+    expect(numArray.sumRange(0, 8)).toBe(45);
+    expect(numArray.sumRange(0, 2)).toBe(9);
+    numArray.update(1, 2);
+    expect(numArray.sumRange(0, 2)).toBe(8);
+    expect(numArray.sumRange(3, 4)).toBe(10);
+    numArray.update(3, 2);
+    expect(numArray.sumRange(3, 4)).toBe(4);
+  });
+});