data-structure-typed 1.42.9 → 1.43.1

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

@@ -1,6 +1,8 @@
 import {DoublyLinkedList, DoublyLinkedListNode} from '../../../../src';
+import {LinkList as CLinkedList} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
+import {isCompetitor} from "../../../config";
 
 const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
@@ -13,7 +15,16 @@ suite
       list.unshift(i);
     }
   })
-  .add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
+  if (isCompetitor) {
+    suite.add(`${LINEAR.toLocaleString()} competitor unshift`, () => {
+      const list = new CLinkedList<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        list.pushFront(i);
+      }
+    })
+  }
+  suite.add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
     const list = new DoublyLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -0,0 +1,37 @@
+import {PriorityQueue as CPriorityQueue} from 'js-sdsl';
+import {PriorityQueue} from '../../../../src';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+import {isCompetitor} from "../../../config";
+
+const suite = new Benchmark.Suite();
+const {TEN_THOUSAND} = magnitude;
+
+suite
+  .add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+    const pq = new PriorityQueue<number>({comparator: (a, b) => b - a});
+
+    for (let i = 0; i < TEN_THOUSAND; i++) {
+      pq.add(i);
+    }
+
+    for (let i = 0; i < TEN_THOUSAND; i++) {
+      pq.pop();
+    }
+  });
+if (isCompetitor) {
+  suite.add(`${TEN_THOUSAND.toLocaleString()} competitor add & pop`, () => {
+    const pq = new CPriorityQueue<number>();
+
+    for (let i = 0; i < TEN_THOUSAND; i++) {
+      pq.push(i);
+    }
+
+    for (let i = 0; i < TEN_THOUSAND; i++) {
+      pq.pop();
+    }
+  });
+
+}
+
+export {suite};

package/test/performance/data-structures/queue/deque.test.ts

@@ -1,6 +1,8 @@
 import {Deque} from '../../../../src';
+import {Deque as CDeque} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
+import {isCompetitor} from "../../../config";
 
 export const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
@@ -12,7 +14,15 @@ suite
       deque.push(i);
     }
   })
-  .add(`${LINEAR.toLocaleString()} shift`, () => {
+  if (isCompetitor) {
+    suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
+      const deque = new CDeque<number>();
+      for (let i = 0; i < LINEAR; i++) {
+        deque.pushBack(i);
+      }
+    })
+  }
+  suite.add(`${LINEAR.toLocaleString()} shift`, () => {
     const deque = new Deque<number>();
     for (let i = 0; i < LINEAR; i++) {
       deque.push(i);

package/test/performance/data-structures/queue/queue.test.ts

@@ -1,6 +1,8 @@
 import {Queue} from '../../../../src';
+import {Queue as CQueue} from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import {magnitude} from '../../../utils';
+import {isCompetitor} from "../../../config";
 
 const suite = new Benchmark.Suite();
 const {LINEAR} = magnitude;
@@ -13,7 +15,16 @@ suite
       queue.push(i);
     }
   })
-  .add(`${LINEAR.toLocaleString()} push & shift`, () => {
+  if (isCompetitor) {
+    suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
+      const queue = new CQueue<number>();
+
+      for (let i = 0; i < LINEAR; i++) {
+        queue.push(i);
+      }
+    })
+  }
+  suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
     const queue = new Queue<number>();
 
     for (let i = 0; i < LINEAR; i++) {

package/test/performance/data-structures/stack/stack.test.ts

@@ -0,0 +1,50 @@
+import {Stack} from '../../../../src';
+import {Stack as CStack} from 'js-sdsl';
+import * as Benchmark from 'benchmark';
+import {magnitude} from '../../../utils';
+import {isCompetitor} from "../../../config";
+
+const suite = new Benchmark.Suite();
+const {LINEAR} = magnitude;
+
+suite
+  .add(`${LINEAR.toLocaleString()} push`, () => {
+    const stack = new Stack<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      stack.push(i);
+    }
+  })
+if (isCompetitor) {
+  suite.add(`${LINEAR.toLocaleString()} competitor push`, () => {
+    const queue = new CStack<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+    }
+  })
+}
+suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+  const queue = new Stack<number>();
+
+  for (let i = 0; i < LINEAR; i++) {
+    queue.push(i);
+  }
+  for (let i = 0; i < LINEAR; i++) {
+    queue.pop();
+  }
+})
+if (isCompetitor) {
+  suite.add(`${LINEAR.toLocaleString()} competitor push & pop`, () => {
+    const queue = new CStack<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      queue.push(i);
+    }
+    for (let i = 0; i < LINEAR; i++) {
+      queue.pop();
+    }
+  })
+}
+
+export {suite};

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,5 +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;
@@ -65,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');
   });
 });
 
@@ -87,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);
 
@@ -191,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]);