data-structure-typed 1.39.0 → 1.39.2

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

@@ -1,4 +1,4 @@
-import {AVLTree, AVLTreeNode, CP} from '../../../../src';
+import {AVLTree, AVLTreeNode, CP, IterationType} from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -109,6 +109,115 @@ describe('AVL Tree Test', () => {
   });
 });
 
+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?.val).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(() => {
@@ -127,3 +236,34 @@ describe('AVLTree APIs test', () => {
     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-tree.test.ts

@@ -71,81 +71,121 @@ describe('BinaryTreeNode', () => {
 });
 
 describe('BinaryTree', () => {
-  let binaryTree: BinaryTree;
+  let tree: BinaryTree;
 
   beforeEach(() => {
-    binaryTree = new BinaryTree();
+    tree = new BinaryTree();
   });
 
   afterEach(() => {
-    binaryTree.clear();
+    tree.clear();
   });
 
-  test('should add a node', () => {
-    const node = binaryTree.add(1);
+  it('should add a node', () => {
+    const node = tree.add(1);
     expect(node).not.toBeNull();
-    expect(binaryTree.size).toBe(1);
+    expect(tree.size).toBe(1);
   });
 
-  test('should delete a node', () => {
-    const node = binaryTree.add(1);
-    expect(binaryTree.size).toBe(1);
+  it('should delete a node', () => {
+    const node = tree.add(1);
+    expect(tree.size).toBe(1);
 
     if (node) {
-      const result = binaryTree.delete(node);
+      const result = tree.delete(node, node => node);
       expect(result).toHaveLength(1);
-      expect(binaryTree.size).toBe(0);
+      expect(tree.size).toBe(0);
     }
   });
 
-  test('should add and find nodes', () => {
-    binaryTree.add(1);
-    binaryTree.add(2);
-    binaryTree.add(3);
+  it('should add and find nodes', () => {
+    tree.add(1);
+    tree.add(2);
+    tree.add(3);
+
+    expect(tree.has(1)).toBe(true);
+    expect(tree.has(2)).toBe(true);
+    expect(tree.has(3)).toBe(true);
+    expect(tree.has(4)).toBe(false);
+    const node4 = tree.get(4);
+    expect(tree.has(node4, node => node)).toBe(false);
+  });
 
-    expect(binaryTree.has(1)).toBe(true);
-    expect(binaryTree.has(2)).toBe(true);
-    expect(binaryTree.has(3)).toBe(true);
-    expect(binaryTree.has(4)).toBe(false);
+  it('should getDepth return correct depth', () => {
+    tree.add(1);
+    expect(tree.getDepth(1)).toBe(0);
+    tree.add(2);
+    expect(tree.getDepth(2)).toBe(1);
+    tree.add(3);
+    expect(tree.getDepth(3, 1)).toBe(1);
+    tree.add(4);
+    expect(tree.getDepth(4, 1)).toBe(2);
+    expect(tree.getDepth(4)).toBe(2);
+    expect(tree.getDepth(4, 2)).toBe(1);
   });
 
-  test('should getDepth return correct depth', () => {
-    binaryTree.add(1);
-    expect(binaryTree.getDepth(1)).toBe(0);
-    binaryTree.add(2);
-    expect(binaryTree.getDepth(2)).toBe(1);
-    binaryTree.add(3);
-    expect(binaryTree.getDepth(3, 1)).toBe(1);
-    binaryTree.add(4);
-    expect(binaryTree.getDepth(4, 1)).toBe(2);
-    expect(binaryTree.getDepth(4)).toBe(2);
-    expect(binaryTree.getDepth(4, 2)).toBe(1);
+  it('should traverse in-order', () => {
+    tree.add(null);
+    tree.delete(1);
+    expect(tree.getHeight()).toBe(-1);
+    tree.add(4);
+    tree.add(2);
+    expect(tree.getHeight()).toBe(1);
+    tree.iterationType = IterationType.RECURSIVE;
+    expect(tree.getHeight()).toBe(1);
+    tree.iterationType = IterationType.ITERATIVE;
+
+    tree.add(6);
+    tree.add(1);
+    tree.add(new BinaryTreeNode(3));
+    tree.add(5);
+    tree.add(7);
+
+    const inOrder = tree.dfs(node => node.key);
+
+    expect(inOrder).toEqual([1, 2, 3, 4, 5, 6, 7]);
   });
 
-  test('should traverse in-order', () => {
-    binaryTree.add(4);
-    binaryTree.add(2);
-    binaryTree.add(6);
-    binaryTree.add(1);
-    binaryTree.add(3);
-    binaryTree.add(5);
-    binaryTree.add(7);
+  it('should getLeftMost', () => {
+    tree.addMany([4, 2, 6, 1, 3, 5, 7]);
 
-    const inOrder = binaryTree.dfs(node => node.key);
+    const leftMost = tree.getLeftMost(tree.root, IterationType.RECURSIVE);
+    expect(leftMost?.key).toEqual(1);
+    const rightMost = tree.getRightMost(tree.root, IterationType.RECURSIVE);
+    expect(rightMost?.key).toEqual(7);
+  });
 
-    expect(inOrder).toEqual([1, 2, 3, 4, 5, 6, 7]);
+  it('should isSubtreeBST', () => {
+    tree.addMany([
+      new BinaryTreeNode(4, 4),
+      new BinaryTreeNode(2, 2),
+      new BinaryTreeNode(6, 6),
+      new BinaryTreeNode(1, 1),
+      new BinaryTreeNode(3, 3),
+      new BinaryTreeNode(5, 5),
+      new BinaryTreeNode(7, 7),
+      new BinaryTreeNode(4, 4)
+    ]);
+
+    expect(tree.isSubtreeBST(tree.get(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isSubtreeBST(tree.get(4), IterationType.ITERATIVE)).toBe(true);
   });
 
-  test('should clear the tree', () => {
-    binaryTree.add(1);
-    binaryTree.add(2);
+  it('should subTreeTraverse', () => {
+    tree.addMany([4, 2, 6, 1, 3, 5, 7]);
+    expect(tree.subTreeTraverse(node => node.key, tree.get(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+  });
+
+  it('should clear the tree', () => {
+    tree.add(1);
+    tree.add(2);
 
-    expect(binaryTree.size).toBe(2);
+    expect(tree.size).toBe(2);
 
-    binaryTree.clear();
+    tree.clear();
 
-    expect(binaryTree.size).toBe(0);
-    expect(binaryTree.root).toBeNull();
+    expect(tree.size).toBe(0);
+    expect(tree.root).toBeNull();
   });
 });
 
@@ -166,6 +206,7 @@ describe('BinaryTree Morris Traversal', () => {
 
     expect(result).toEqual(expected);
     expect(tree.dfs(node => node.key, 'in')).toEqual(expected);
+    expect(tree.dfs(node => node.key, 'in', tree.root, IterationType.RECURSIVE)).toEqual(expected);
   });
 
   it('should perform pre-order Morris traversal correctly as dfs traversal', () => {
@@ -224,8 +265,10 @@ describe('BinaryTree traversals', () => {
   const arr = [35, 20, 40, 15, 29, null, 50, null, 16, 28, 30, 45, 55];
   tree.refill(arr);
   expect(tree.dfs(node => node.key, 'pre')).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
+  expect(tree.dfs(node => node.key, 'pre', tree.root, IterationType.RECURSIVE)).toEqual([35, 20, 15, 16, 29, 28, 30, 40, 50, 45, 55]);
   expect(tree.dfs(node => node.key, 'in')).toEqual([15, 16, 20, 28, 29, 30, 35, 40, 45, 50, 55]);
   expect(tree.dfs(node => node.key, 'post')).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
+  expect(tree.dfs(node => node.key, 'post', tree.root, IterationType.RECURSIVE)).toEqual([16, 15, 28, 30, 29, 20, 45, 55, 50, 40, 35]);
   expect(tree.bfs(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
     35, 20, 40, 15, 29, 50, 16, 28, 30, 45, 55
   ]);
@@ -236,4 +279,203 @@ describe('BinaryTree traversals', () => {
   const levels = tree.listLevels(node => node.key);
   expect(levels).toEqual([[35], [20, 40], [15, 29, 50], [16, 28, 30, 45, 55]]);
   isDebug && console.log(levels);
+
+  expect(tree.listLevels(node => node.key, tree.root, IterationType.RECURSIVE)).toEqual([
+    [35],
+    [20, 40],
+    [15, 29, 50],
+    [16, 28, 30, 45, 55]
+  ]);
+  isDebug && console.log(levels);
+});
+
+describe('BinaryTree', () => {
+  let tree: BinaryTree<string>;
+
+  beforeEach(() => {
+    tree = new BinaryTree<string>({iterationType: IterationType.RECURSIVE});
+  });
+
+  afterEach(() => {
+    tree.clear();
+  });
+
+  it('should create an empty BinaryTree', () => {
+    expect(tree.size).toBe(0);
+    expect(tree.isEmpty()).toBe(true);
+    expect(tree.root).toBe(null);
+  });
+
+  it('should add nodes to the tree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    expect(tree.size).toBe(3);
+    expect(tree.isEmpty()).toBe(false);
+    expect(tree.root?.key).toBe(5);
+  });
+
+  it('should clear the BinaryTree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    tree.clear();
+
+    expect(tree.size).toBe(0);
+    expect(tree.isEmpty()).toBe(true);
+    expect(tree.root).toBe(null);
+  });
+
+  it('should get nodes by key', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    const nodeA = tree.get(5);
+    const nodeB = tree.get(3);
+
+    expect(nodeA?.key).toBe(5);
+    expect(nodeA?.val).toBe('A');
+    expect(nodeB?.key).toBe(3);
+    expect(nodeB?.val).toBe('B');
+  });
+
+  it('should return null when getting a non-existent node', () => {
+    tree.add(5, 'A');
+
+    const node = tree.get(3);
+
+    expect(node).toBe(null);
+  });
+
+  it('should get the depth of a node', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    expect(tree.getDepth(7)).toBe(1);
+    expect(tree.getDepth(3)).toBe(1);
+  });
+
+  it('should get the height of the tree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    expect(tree.getHeight()).toBe(1);
+    expect(tree.getHeight(undefined, IterationType.RECURSIVE)).toBe(1);
+    expect(tree.getMinHeight(undefined, IterationType.RECURSIVE)).toBe(1);
+  });
+
+  it('should check if the tree is a binary search tree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    expect(tree.isBST()).toBe(true);
+  });
+
+  it('should perform a depth-first traversal', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    const result = tree.dfs();
+    expect(result).toEqual([3, 5, 7]);
+    // Add assertions for the result of depth-first traversal
+  });
+
+  it('should perform a breadth-first traversal', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    const result = tree.bfs(node => node.key);
+    expect(result).toEqual([5, 3, 7]);
+    // Add assertions for the result of breadth-first traversal
+  });
+
+  it('should list levels of the tree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    const levels = tree.listLevels();
+    expect(levels).toEqual([[5], [3, 7]]);
+    // Add assertions for the levels of the tree
+  });
+
+  it('should delete nodes from the tree', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    tree.delete(3);
+
+    expect(tree.size).toBe(2);
+    expect(tree.get(3)).toBe(null);
+  });
+
+  it('should check if the tree is perfectly balanced', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+  });
+
+  it('should get nodes by a custom callback', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    const nodes = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.val);
+
+    expect(nodes.length).toBe(1);
+    expect(nodes[0].key).toBe(3);
+
+    const nodesRec = tree.getNodes(
+      'B',
+      (node: BinaryTreeNode<string>) => node.val,
+      false,
+      tree.root,
+      IterationType.RECURSIVE
+    );
+
+    expect(nodesRec.length).toBe(1);
+    expect(nodesRec[0].key).toBe(3);
+  });
+
+  it('should perform Morris traversal', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    tree.iterationType = IterationType.ITERATIVE;
+    // @ts-ignore
+    expect([...tree]).toEqual([3, 5, 7]);
+    tree.iterationType = IterationType.RECURSIVE;
+    // @ts-ignore
+    expect([...tree]).toEqual([3, 5, 7]);
+    tree.iterationType = IterationType.ITERATIVE;
+
+    const result = tree.morris();
+    expect(result).toEqual([3, 5, 7]);
+    // Add assertions for the result of Morris traversal
+  });
+
+  it('should perform delete all', () => {
+    tree.add(5, 'A');
+    tree.add(3, 'B');
+    tree.add(7, 'C');
+
+    tree.delete(5);
+    tree.delete(7);
+    tree.delete(3);
+
+    expect(tree.root).toBe(null);
+    expect(tree.getHeight()).toBe(-1);
+  });
 });