data-structure-typed 1.46.8 → 1.46.9

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

@@ -189,9 +189,9 @@ describe('BinaryTree', () => {
     tree.add(4);
     tree.add(2);
     expect(tree.getHeight()).toBe(1);
-    tree.iterationType = IterationType.RECURSIVE;
+    tree.options.iterationType = IterationType.RECURSIVE;
     expect(tree.getHeight()).toBe(1);
-    tree.iterationType = IterationType.ITERATIVE;
+    tree.options.iterationType = IterationType.ITERATIVE;
 
     tree.add(6);
     tree.add(1);
@@ -541,11 +541,11 @@ describe('BinaryTree', () => {
     tree.add(3, 'B');
     tree.add(7, 'C');
 
-    tree.iterationType = IterationType.ITERATIVE;
-    expect([...tree]).toEqual([3, 5, 7]);
-    tree.iterationType = IterationType.RECURSIVE;
-    expect([...tree]).toEqual([3, 5, 7]);
-    tree.iterationType = IterationType.ITERATIVE;
+    tree.options.iterationType = IterationType.ITERATIVE;
+    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    tree.options.iterationType = IterationType.RECURSIVE;
+    expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
+    tree.options.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);
@@ -564,3 +564,58 @@ describe('BinaryTree', () => {
     expect(tree.getHeight()).toBe(-1);
   });
 });
+
+
+describe('BinaryTree iterative methods test', () => {
+  let binaryTree: BinaryTree<string>;
+  beforeEach(() => {
+    binaryTree = new BinaryTree();
+    binaryTree.add(1, 'a');
+    binaryTree.add(2, 'b');
+    binaryTree.add(3, 'c');
+  });
+
+  test('The node obtained by get Node should match the node type', () => {
+    const node3 = binaryTree.getNode(3);
+    expect(node3).toBeInstanceOf(BinaryTreeNode);
+  });
+
+  test('forEach should iterate over all elements', () => {
+    const mockCallback = jest.fn();
+    binaryTree.forEach((entry) => {
+      mockCallback(entry);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0][0]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[1][0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+  });
+
+  test('filter should return a new tree with filtered elements', () => {
+    const filteredTree = binaryTree.filter(([key]) => key > 1);
+    expect(filteredTree.size).toBe(2);
+    expect([...filteredTree]).toEqual([[3, 'c'], [2, 'b']]);
+  });
+
+  test('map should return a new tree with modified elements', () => {
+    const mappedTree = binaryTree.map(([key]) => (key * 2).toString());
+    expect(mappedTree.size).toBe(3);
+    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+  });
+
+  test('reduce should accumulate values', () => {
+    const sum = binaryTree.reduce((acc, [key]) => acc + key, 0);
+    expect(sum).toBe(6);
+  });
+
+  test('[Symbol.iterator] should provide an iterator', () => {
+    const entries = [];
+    for (const entry of binaryTree) {
+      entries.push(entry);
+    }
+
+    expect(entries.length).toBe(3);
+    expect(entries).toEqual([[2, 'b'], [1, 'a'], [3, 'c']]);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { BST, BSTNode, CP, IterationType } from '../../../../src';
+import { BinaryTreeNode, BST, BSTNode, CP, IterationType } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -851,3 +851,58 @@ describe('BST Performance test', function () {
     ]);
   });
 });
+
+describe('BST iterative methods test', () => {
+  let bst: BST<string>;
+  beforeEach(() => {
+    bst = new BST();
+    bst.add(1, 'a');
+    bst.add(2, 'b');
+    bst.add(3, 'c');
+  });
+
+  test('The node obtained by get Node should match the node type', () => {
+    const node3 = bst.getNode(3);
+    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    expect(node3).toBeInstanceOf(BSTNode);
+  });
+
+  test('forEach should iterate over all elements', () => {
+    const mockCallback = jest.fn();
+    bst.forEach((entry) => {
+      mockCallback(entry);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+  });
+
+  test('filter should return a new tree with filtered elements', () => {
+    const filteredTree = bst.filter(([key]) => key > 1);
+    expect(filteredTree.size).toBe(2);
+    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+  });
+
+  test('map should return a new tree with modified elements', () => {
+    const mappedTree = bst.map(([key]) => (key * 2).toString());
+    expect(mappedTree.size).toBe(3);
+    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+  });
+
+  test('reduce should accumulate values', () => {
+    const sum = bst.reduce((acc, [key]) => acc + key, 0);
+    expect(sum).toBe(6);
+  });
+
+  test('[Symbol.iterator] should provide an iterator', () => {
+    const entries = [];
+    for (const entry of bst) {
+      entries.push(entry);
+    }
+
+    expect(entries.length).toBe(3);
+    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+  });
+});

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

@@ -1,4 +1,4 @@
-import { IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode } from '../../../../src';
+import { BinaryTreeNode, BSTNode, IterationType, RBTNColor, RedBlackTree, RedBlackTreeNode } from '../../../../src';
 import { getRandomInt, getRandomIntArray, magnitude } from '../../../utils';
 import { isDebugTest } from '../../../config';
 import { OrderedMap } from 'js-sdsl';
@@ -67,7 +67,7 @@ describe('RedBlackTree', () => {
 
     it('should handle an empty tree', () => {
       const minNode = tree.getLeftMost(tree.root);
-      expect(minNode).toBe(tree.NIL);
+      expect(minNode).toBe(tree.Sentinel);
     });
   });
 
@@ -85,7 +85,7 @@ describe('RedBlackTree', () => {
 
     it('should handle an empty tree', () => {
       const maxNode = tree.getRightMost(tree.root);
-      expect(maxNode).toBe(tree.NIL);
+      expect(maxNode).toBe(tree.Sentinel);
     });
   });
 
@@ -109,7 +109,7 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(10);
       const successorNode = tree.getSuccessor(node!);
-      // TODO not sure if it should be undefined or tree.NIL
+      // TODO not sure if it should be undefined or tree.Sentinel
       expect(successorNode).toBe(undefined);
     });
   });
@@ -134,7 +134,7 @@ describe('RedBlackTree', () => {
 
       const node = tree.getNode(20);
       const predecessorNode = tree.getPredecessor(node!);
-      // TODO not sure if it should be tree.NIL or something else.
+      // TODO not sure if it should be tree.Sentinel or something else.
       expect(predecessorNode).toBe(tree.getNode(10));
     });
   });
@@ -235,28 +235,28 @@ describe('RedBlackTree', () => {
     expect(node5F?.parent).toBe(node10F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe(RBTNColor.RED);
-    expect(node21F?.left).toBe(tree.NIL);
-    expect(node21F?.right).toBe(tree.NIL);
+    expect(node21F?.left).toBe(tree.Sentinel);
+    expect(node21F?.right).toBe(tree.Sentinel);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe(RBTNColor.RED);
-    expect(node6F?.left).toBe(tree.NIL);
-    expect(node6F?.right).toBe(tree.NIL);
+    expect(node6F?.left).toBe(tree.Sentinel);
+    expect(node6F?.right).toBe(tree.Sentinel);
     expect(node6F?.parent).toBe(node5F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe(RBTNColor.RED);
-    expect(node2F?.left).toBe(tree.NIL);
-    expect(node2F?.right).toBe(tree.NIL);
+    expect(node2F?.left).toBe(tree.Sentinel);
+    expect(node2F?.right).toBe(tree.Sentinel);
     expect(node2F?.parent).toBe(node5F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node20F);
     tree.delete(5);
     node10F = tree.getNode(10);
@@ -279,28 +279,28 @@ describe('RedBlackTree', () => {
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node20F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe(RBTNColor.RED);
-    expect(node21F?.left).toBe(tree.NIL);
-    expect(node21F?.right).toBe(tree.NIL);
+    expect(node21F?.left).toBe(tree.Sentinel);
+    expect(node21F?.right).toBe(tree.Sentinel);
     expect(node21F?.parent).toBe(node20F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe(RBTNColor.BLACK);
     expect(node6F?.left).toBe(node2F);
-    expect(node6F?.right).toBe(tree.NIL);
+    expect(node6F?.right).toBe(tree.Sentinel);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe(RBTNColor.RED);
-    expect(node2F?.left).toBe(tree.NIL);
-    expect(node2F?.right).toBe(tree.NIL);
+    expect(node2F?.left).toBe(tree.Sentinel);
+    expect(node2F?.right).toBe(tree.Sentinel);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node20F);
     tree.delete(20);
     node10F = tree.getNode(10);
@@ -319,28 +319,28 @@ describe('RedBlackTree', () => {
     expect(node5F).toBe(undefined);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node21F);
     expect(node21F?.key).toBe(21);
     expect(node21F?.color).toBe(RBTNColor.BLACK);
     expect(node21F?.left).toBe(node15F);
-    expect(node21F?.right).toBe(tree.NIL);
+    expect(node21F?.right).toBe(tree.Sentinel);
     expect(node21F?.parent).toBe(node10F);
     expect(node6F?.key).toBe(6);
     expect(node6F?.color).toBe(RBTNColor.BLACK);
     expect(node6F?.left).toBe(node2F);
-    expect(node6F?.right).toBe(tree.NIL);
+    expect(node6F?.right).toBe(tree.Sentinel);
     expect(node6F?.parent).toBe(node10F);
     expect(node2F?.key).toBe(2);
     expect(node2F?.color).toBe(RBTNColor.RED);
-    expect(node2F?.left).toBe(tree.NIL);
-    expect(node2F?.right).toBe(tree.NIL);
+    expect(node2F?.left).toBe(tree.Sentinel);
+    expect(node2F?.right).toBe(tree.Sentinel);
     expect(node2F?.parent).toBe(node6F);
     expect(node15F?.key).toBe(15);
     expect(node15F?.color).toBe(RBTNColor.RED);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(node21F);
   });
 
@@ -350,8 +350,8 @@ describe('RedBlackTree', () => {
     tree.add(5);
     tree.add(15);
     const node15F = tree.getNode(15);
-    expect(node15F?.left).toBe(tree.NIL);
-    expect(node15F?.right).toBe(tree.NIL);
+    expect(node15F?.left).toBe(tree.Sentinel);
+    expect(node15F?.right).toBe(tree.Sentinel);
     expect(node15F?.parent).toBe(tree.getNode(5));
 
     tree.add(25);
@@ -366,8 +366,8 @@ describe('RedBlackTree', () => {
     tree.add(155);
     tree.add(225);
     const node225F = tree.getNode(225);
-    expect(node225F?.left).toBe(tree.NIL);
-    expect(node225F?.right).toBe(tree.NIL);
+    expect(node225F?.left).toBe(tree.Sentinel);
+    expect(node225F?.right).toBe(tree.Sentinel);
     expect(node225F?.parent?.key).toBe(155);
     tree.add(7);
 
@@ -393,14 +393,14 @@ describe('RedBlackTree', () => {
     const node50 = tree.getNode(50);
     expect(node50?.key).toBe(50);
     expect(node50?.left?.key).toBe(33);
-    expect(node50?.right).toBe(tree.NIL);
+    expect(node50?.right).toBe(tree.Sentinel);
     const node15Fo = tree.getNode(15);
 
     expect(node15Fo?.key).toBe(15);
-    expect(node15Fo?.left).toBe(tree.NIL);
+    expect(node15Fo?.left).toBe(tree.Sentinel);
     const node225S = tree.getNode(225);
-    expect(node225S?.left).toBe(tree.NIL);
-    expect(node225S?.right).toBe(tree.NIL);
+    expect(node225S?.left).toBe(tree.Sentinel);
+    expect(node225S?.right).toBe(tree.Sentinel);
     expect(node225S?.parent?.key).toBe(155);
     // TODO
     // expect(tree.getNode(0)).toBe(undefined);
@@ -465,7 +465,7 @@ describe('RedBlackTree', () => {
       tree.delete(getRandomInt(-100, 1000));
     }
 
-    // TODO there is a bug when dfs the tree with NIL node
+    // TODO there is a bug when dfs the tree with Sentinel node
     // expect(tree.isBST()).toBe(true);
   });
   const { HUNDRED_THOUSAND } = magnitude;
@@ -490,7 +490,7 @@ describe('RedBlackTree', () => {
 
   it('duplicates', () => {
     tree.addMany([9, 8, 7, 8, 8, 8, 2, 3, 6, 5, 5, 4]);
-    tree.print();
+    isDebug && tree.print();
 
     expect(tree.size).toBe(8);
     expect(tree.isBST()).toBe(true);
@@ -505,3 +505,59 @@ describe('RedBlackTree', () => {
     expect(tree.isAVLBalanced()).toBe(false);
   })
 });
+
+describe('RedBlackTree iterative methods test', () => {
+  let rbTree: RedBlackTree<string>;
+  beforeEach(() => {
+    rbTree = new RedBlackTree();
+    rbTree.add(1, 'a');
+    rbTree.add(2, 'b');
+    rbTree.add(3, 'c');
+  });
+
+  test('The node obtained by get Node should match the node type', () => {
+    const node3 = rbTree.getNode(3);
+    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    expect(node3).toBeInstanceOf(BSTNode);
+    expect(node3).toBeInstanceOf(RedBlackTreeNode);
+  });
+
+  test('forEach should iterate over all elements', () => {
+    const mockCallback = jest.fn();
+    rbTree.forEach((entry) => {
+      mockCallback(entry);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
+    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
+    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+  });
+
+  test('filter should return a new tree with filtered elements', () => {
+    const filteredTree = rbTree.filter(([key]) => key > 1);
+    expect(filteredTree.size).toBe(2);
+    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+  });
+
+  test('map should return a new tree with modified elements', () => {
+    const mappedTree = rbTree.map(([key]) => (key * 2).toString());
+    expect(mappedTree.size).toBe(3);
+    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+  });
+
+  test('reduce should accumulate values', () => {
+    const sum = rbTree.reduce((acc, [key]) => acc + key, 0);
+    expect(sum).toBe(6);
+  });
+
+  test('[Symbol.iterator] should provide an iterator', () => {
+    const entries = [];
+    for (const entry of rbTree) {
+      entries.push(entry);
+    }
+
+    expect(entries.length).toBe(3);
+    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+  });
+});