data-structure-typed 1.42.8 → 1.43.0

package/test/integration/index.html

@@ -28,13 +28,13 @@
 
 
     const queue = new Queue();
-    for (let i = 0; i < 1000000; i++) {
+    for (let i = 0; i < 100000; i++) {
       queue.enqueue(i);
     }
     let last = 0;
     const startTime = performance.now();
 
-    for (let i = 0; i < 1000000; i++) {
+    for (let i = 0; i < 100000; i++) {
       last = queue.dequeue();
     }
 
@@ -44,6 +44,28 @@
     console.error(e);
   }
 
+  try {
+    const {BinaryTree} = dataStructureTyped;
+    const tree = new BinaryTree();
+    tree.add(3);
+    tree.add(12);
+    tree.addMany([1, 6, 9, 8,5,2,3,4,7])
+    tree.add(10);
+    console.log(tree.isPerfectlyBalanced());
+    tree.print();
+
+    const node3 = tree.getNode(3);
+    if (node3) node3.right = tree.createNode(1);
+    console.log(tree.isPerfectlyBalanced());
+    tree.print();
+
+    tree.clear();
+    tree.addMany([1, null, 2, null, 3, null, 4, null, 5, null, 6, null]);
+    console.log(tree.isPerfectlyBalanced());
+    tree.print();
+  } catch (e) {
+    console.error(e);
+  }
 </script>
 
 </body>

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

@@ -7,6 +7,7 @@ describe('AVL Tree Test', () => {
 
     for (const i of arr) tree.add(i, i);
 
+    tree.add(null);
     const node6 = tree.getNode(6);
 
     expect(node6 && tree.getHeight(node6)).toBe(3);
@@ -42,7 +43,7 @@ describe('AVL Tree Test', () => {
     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.delete(tree.getNode(11))[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 

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

@@ -1,4 +1,6 @@
 import {BinaryTree, BinaryTreeNode, IterationType} from '../../../../src';
+import {getRandomIntArray} from "../../../utils";
+import {FamilyPosition} from "binary-tree-typed";
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -64,8 +66,25 @@ describe('BinaryTreeNode', () => {
     root.right = rightChild;
 
     expect(leftChild.familyPosition).toBe('LEFT');
+    leftChild.right = new BinaryTreeNode<number>(4);
     expect(rightChild.familyPosition).toBe('RIGHT');
     expect(root.familyPosition).toBe('ROOT');
+    expect(leftChild.familyPosition).toBe('ROOT_LEFT');
+    rightChild.left = new BinaryTreeNode<number>(5);
+    expect(rightChild.familyPosition).toBe('ROOT_RIGHT');
+
+  });
+
+  it('should determine only right child family position correctly', () => {
+    const root = new BinaryTreeNode<number>(1);
+    const rightChild = new BinaryTreeNode<number>(3);
+    const isolated = new BinaryTreeNode<number>(2);
+
+    root.right = rightChild;
+
+    expect(rightChild.familyPosition).toBe('RIGHT');
+    expect(isolated.familyPosition).toBe(FamilyPosition.ISOLATED);
+    expect(root.familyPosition).toBe('ROOT');
   });
 });
 
@@ -86,19 +105,43 @@ describe('BinaryTree', () => {
     expect(tree.size).toBe(1);
   });
 
-  it('should delete a node', () => {
+  it('should delete nodes', () => {
+    expect(tree.getHeight(tree.root, IterationType.ITERATIVE)).toBe(-1)
+    expect(tree.getMinHeight()).toBe(-1)
     const node = tree.add(1);
     expect(tree.size).toBe(1);
 
+    const leftChild = new BinaryTreeNode<number>(2);
+    const rightChild = new BinaryTreeNode<number>(3);
+    tree.add(leftChild);
+    tree.add(rightChild);
+    const root = tree.root;
+
+
+    expect(leftChild.familyPosition).toBe('LEFT');
+    tree.add(null);
+    tree.add(new BinaryTreeNode<number>(4));
+    expect(rightChild.familyPosition).toBe('RIGHT');
+    expect(root?.familyPosition).toBe('ROOT');
+    expect(leftChild.familyPosition).toBe('ROOT_LEFT');
+    tree.add(new BinaryTreeNode<number>(5));
+    expect(rightChild.familyPosition).toBe('ROOT_RIGHT');
+
+    tree.delete(new BinaryTreeNode<number>(200));
+    tree.delete(rightChild)
+
     if (node) {
-      const result = tree.delete(node, node => node);
+      const result = tree.delete(node);
       expect(result).toHaveLength(1);
-      expect(tree.size).toBe(0);
+      expect(tree.size).toBe(3);
+      expect(tree.getMinHeight(tree.root, IterationType.RECURSIVE)).toBe(1)
     }
+
   });
 
   it('should add and find nodes', () => {
     tree.add(1, 1);
+    tree.add(undefined);
     tree.add(2, 2);
     tree.add(3, 3);
 
@@ -112,6 +155,24 @@ describe('BinaryTree', () => {
     expect(tree.has('3', node => node.value?.toString())).toBe(true);
   });
 
+
+  it('should be a balance tree after malicious manipulation', () => {
+    tree.add(3);
+    tree.add(12);
+    tree.addMany(getRandomIntArray(100, 1, 100))
+    tree.add(10);
+
+    expect(tree.isPerfectlyBalanced()).toBe(true);
+    const node3 = tree.getNode(3);
+
+    if (node3) node3.right = tree.createNode(1);
+    expect(tree.isPerfectlyBalanced()).toBe(false);
+
+    tree.clear();
+    tree.addMany([1, null, 2, null, 3, null, 4, null, 5, null, 6, null]);
+    expect(tree.isPerfectlyBalanced()).toBe(false);
+  });
+
   it('should getDepth return correct depth', () => {
     tree.add(1);
     expect(tree.getDepth(1)).toBe(0);
@@ -172,6 +233,15 @@ describe('BinaryTree', () => {
     expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
   });
 
+  it('should isSubtreeBST', () => {
+    tree.addMany([4, 2, 6, 1, 3, 5, 7, 4]);
+
+    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.RECURSIVE)).toBe(true);
+    expect(tree.isSubtreeBST(tree.getNode(4), IterationType.ITERATIVE)).toBe(true);
+    expect(tree.getNodes(2, undefined, false, null)).toEqual([])
+    expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)])
+  });
+
   it('should subTreeTraverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
     expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
@@ -480,10 +550,8 @@ describe('BinaryTree', () => {
     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;
 

package/test/unit/data-structures/linked-list/doubly-linked-list.test.ts

@@ -54,7 +54,6 @@ describe('DoublyLinkedList Operation Test', () => {
   });
 
   it('should insertAfter tail', () => {
-    // @ts-ignore
     expect([...list]).toEqual([1, 2, 3, 4, 5]);
   });
 });

package/test/unit/data-structures/linked-list/singly-linked-list.test.ts

@@ -441,7 +441,6 @@ describe('SinglyLinkedList', () => {
     list.push(3);
     const array = list.toArray();
     expect(array).toEqual([1, 2, 3]);
-    // @ts-ignore
     expect([...list]).toEqual([1, 2, 3]);
   });