data-structure-typed 1.33.2 → 1.33.5

package/src/types/data-structures/bst.ts

@@ -0,0 +1,13 @@
+import {BSTNode} from '../../data-structures/binary-tree';
+import type {BinaryTreeOptions} from './binary-tree';
+import {BinaryTreeNodeId} from './abstract-binary-tree';
+
+export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
+
+// prettier-ignore
+export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type BSTOptions = BinaryTreeOptions & {
+  comparator?: BSTComparator,
+}
+
+export enum CP {lt = 'lt', eq = 'eq', gt = 'gt'}

package/src/types/data-structures/directed-graph.ts

@@ -0,0 +1,8 @@
+// 0 means unknown, 1 means visiting, 2 means visited;
+export type TopologicalStatus = 0 | 1 | 2;
+
+export enum TopologicalProperty {
+  VAL = 'VAL',
+  NODE = 'NODE',
+  ID = 'ID'
+}

package/src/types/data-structures/doubly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/heap.ts

@@ -0,0 +1,5 @@
+export type HeapOptions<T> = {
+  priorityExtractor?: (element: T) => number;
+  // TODO there is an idea that support chaining which is for conveniently using the data structure
+  // isChaining? : boolean
+};

package/src/types/data-structures/index.ts

@@ -0,0 +1,15 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './abstract-graph';
+export * from './map-graph';
+export * from './abstract-binary-tree';
+export * from './rb-tree';
+export * from './directed-graph';
+export * from './priority-queue';
+export * from './heap';
+export * from './singly-linked-list';
+export * from './doubly-linked-list';
+export * from './navigator';

package/src/types/data-structures/map-graph.ts

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

package/src/types/data-structures/navigator.ts

@@ -0,0 +1,13 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+export type Turning = {[key in Direction]: Direction};
+
+export type NavigatorParams<T = any> = {
+  matrix: T[][];
+  turning: Turning;
+  onMove: (cur: [number, number]) => void;
+  init: {
+    cur: [number, number];
+    charDir: Direction;
+    VISITED: T;
+  };
+};

package/src/types/data-structures/priority-queue.ts

@@ -0,0 +1,9 @@
+export type PriorityQueueComparator<T> = (a: T, b: T) => number;
+
+export type PriorityQueueOptions<T> = {
+  nodes?: T[];
+  isFix?: boolean;
+  comparator: PriorityQueueComparator<T>;
+};
+
+export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

package/src/types/data-structures/rb-tree.ts

@@ -0,0 +1,8 @@
+import {BinaryTreeOptions} from './binary-tree';
+import {RBTreeNode} from '../../data-structures/binary-tree';
+
+export enum RBColor { RED = 'RED', BLACK = 'BLACK'}
+
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type RBTreeOptions = BinaryTreeOptions & {}

package/src/types/data-structures/segment-tree.ts

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

package/src/types/data-structures/singly-linked-list.ts

@@ -0,0 +1 @@
+export {};

package/src/types/data-structures/tree-multiset.ts

@@ -0,0 +1,6 @@
+import {TreeMultisetNode} from '../../data-structures/binary-tree';
+import {AVLTreeOptions} from './avl-tree';
+
+export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeById'> & {}

package/src/types/helpers.ts

@@ -0,0 +1 @@
+export {};

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './helpers';
+export * from './utils';

package/src/types/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './validate-type';

package/src/types/utils/utils.ts

@@ -0,0 +1,6 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/types/utils/validate-type.ts

@@ -0,0 +1,35 @@
+export type KeyValueObject = {[key: string]: any};
+
+export type KeyValueObjectWithId = {[key: string]: any; id: string | number | symbol};
+
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+
+export type ObjectWithoutId = Omit<KeyValueObject, 'id'>;
+
+export type ObjectWithNonNumberId = {
+  [key: string]: any;
+  id: string | boolean | symbol | null | object | undefined;
+};
+
+export type ObjectWithNumberId = {
+  [key: string]: any;
+  id: number;
+};
+
+export type RestrictValById =
+  | NonNumberNonObjectButDefined
+  | ObjectWithoutId
+  | ObjectWithNonNumberId
+  | ObjectWithNumberId;
+
+export type DummyAny =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | object
+  | symbol
+  | void
+  | ((...args: []) => any)
+  | never;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './utils';

package/src/utils/utils.ts

@@ -0,0 +1,79 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type {Thunk, ToThunkFn, TrlAsyncFn, TrlFn} from '../types';
+
+export const uuidV4 = function () {
+  return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
+    const r = (Math.random() * 16) | 0,
+      v = c == 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export const arrayRemove = function <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean): T[] {
+  let i = -1,
+    len = array ? array.length : 0;
+  const result = [];
+
+  while (++i < len) {
+    const value = array[i];
+    if (predicate(value, i, array)) {
+      result.push(value);
+      Array.prototype.splice.call(array, i--, 1);
+      len--;
+    }
+  }
+
+  return result;
+};
+
+export const THUNK_SYMBOL = Symbol('thunk');
+
+export const isThunk = (fnOrValue: any) => {
+  return typeof fnOrValue === 'function' && fnOrValue.__THUNK__ === THUNK_SYMBOL;
+};
+
+export const toThunk = (fn: ToThunkFn): Thunk => {
+  const thunk = () => fn();
+  thunk.__THUNK__ = THUNK_SYMBOL;
+  return thunk;
+};
+
+export const trampoline = (fn: TrlFn) => {
+  const cont = (...args: [...Parameters<TrlFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    (...args: [...Parameters<TrlFn>]) => {
+      let result = fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};
+
+export const trampolineAsync = (fn: TrlAsyncFn) => {
+  const cont = (...args: [...Parameters<TrlAsyncFn>]) => toThunk(() => fn(...args));
+
+  return Object.assign(
+    async (...args: [...Parameters<TrlAsyncFn>]) => {
+      let result = await fn(...args);
+
+      while (isThunk(result) && typeof result === 'function') {
+        result = await result();
+      }
+
+      return result;
+    },
+    {cont}
+  );
+};

package/test/integration/avl-tree.test.ts

@@ -2,7 +2,6 @@ import {AVLTree} from 'avl-tree-typed';
 
 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();
 
@@ -16,7 +15,6 @@ describe('AVL Tree Test', () => {
     const getNodeById = tree.get(10, 'id');
     expect(getNodeById?.id).toBe(10);
 
-
     const getMinNodeByRoot = tree.getLeftMost();
     expect(getMinNodeByRoot?.id).toBe(1);
 
@@ -30,7 +28,6 @@ describe('AVL Tree Test', () => {
     const lesserSum = tree.lesserSum(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);
 
@@ -44,56 +41,56 @@ describe('AVL Tree Test', () => {
     expect(bfs[0].id).toBe(8);
     expect(bfs[bfs.length - 1].id).toBe(16);
 
-    expect(tree.remove(11, true)[0].deleted?.id).toBe(11);
+    expect(tree.remove(11)[0].deleted?.id).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 
-    expect(tree.remove(1, true)[0].deleted?.id).toBe(1);
+    expect(tree.remove(1)[0].deleted?.id).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(4, true)[0].deleted?.id).toBe(4);
+    expect(tree.remove(4)[0].deleted?.id).toBe(4);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(10, true)[0].deleted?.id).toBe(10);
+    expect(tree.remove(10)[0].deleted?.id).toBe(10);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(15, true)[0].deleted?.id).toBe(15);
+    expect(tree.remove(15)[0].deleted?.id).toBe(15);
     expect(tree.isAVLBalanced()).toBe(true);
 
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(5, true)[0].deleted?.id).toBe(5);
+    expect(tree.remove(5)[0].deleted?.id).toBe(5);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(13, true)[0].deleted?.id).toBe(13);
+    expect(tree.remove(13)[0].deleted?.id).toBe(13);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(3, true)[0].deleted?.id).toBe(3);
+    expect(tree.remove(3)[0].deleted?.id).toBe(3);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(8, true)[0].deleted?.id).toBe(8);
+    expect(tree.remove(8)[0].deleted?.id).toBe(8);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(6, true)[0].deleted?.id).toBe(6);
-    expect(tree.remove(6, true).length).toBe(0);
+    expect(tree.remove(6)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6).length).toBe(0);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(7, true)[0].deleted?.id).toBe(7);
+    expect(tree.remove(7)[0].deleted?.id).toBe(7);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(9, true)[0].deleted?.id).toBe(9);
+    expect(tree.remove(9)[0].deleted?.id).toBe(9);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
-    expect(tree.remove(14, true)[0].deleted?.id).toBe(14);
+    expect(tree.remove(14)[0].deleted?.id).toBe(14);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(1);
 

package/test/integration/bst.test.ts

@@ -26,7 +26,6 @@ describe('Individual package BST operations test', () => {
     const nodeVal9 = bst.get(9, 'val');
     expect(nodeVal9?.id).toBe(9);
 
-
     const leftMost = bst.getLeftMost();
     expect(leftMost?.id).toBe(1);
 
@@ -56,7 +55,7 @@ describe('Individual package BST operations test', () => {
     expect(bfsNodesAfterBalanced[0].id).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
 
-    const removed11 = bst.remove(11, true);
+    const removed11 = bst.remove(11);
     expect(removed11).toBeInstanceOf(Array);
     expect(removed11[0]).toBeDefined();
     expect(removed11[0].deleted).toBeDefined();
@@ -67,7 +66,7 @@ describe('Individual package BST operations test', () => {
 
     expect(bst.getHeight(15)).toBe(1);
 
-    const removed1 = bst.remove(1, true);
+    const removed1 = bst.remove(1);
     expect(removed1).toBeInstanceOf(Array);
     expect(removed1[0]).toBeDefined();
     expect(removed1[0].deleted).toBeDefined();
@@ -77,7 +76,7 @@ describe('Individual package BST operations test', () => {
 
     expect(bst.getHeight()).toBe(4);
 
-    const removed4 = bst.remove(4, true);
+    const removed4 = bst.remove(4);
     expect(removed4).toBeInstanceOf(Array);
     expect(removed4[0]).toBeDefined();
     expect(removed4[0].deleted).toBeDefined();
@@ -85,7 +84,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(4);
 
-    const removed10 = bst.remove(10, true);
+    const removed10 = bst.remove(10);
     expect(removed10).toBeInstanceOf(Array);
     expect(removed10[0]).toBeDefined();
     expect(removed10[0].deleted).toBeDefined();
@@ -93,7 +92,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(4);
 
-    const removed15 = bst.remove(15, true);
+    const removed15 = bst.remove(15);
     expect(removed15).toBeInstanceOf(Array);
     expect(removed15[0]).toBeDefined();
     expect(removed15[0].deleted).toBeDefined();
@@ -102,7 +101,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
-    const removed5 = bst.remove(5, true);
+    const removed5 = bst.remove(5);
     expect(removed5).toBeInstanceOf(Array);
     expect(removed5[0]).toBeDefined();
     expect(removed5[0].deleted).toBeDefined();
@@ -111,7 +110,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
-    const removed13 = bst.remove(13, true);
+    const removed13 = bst.remove(13);
     expect(removed13).toBeInstanceOf(Array);
     expect(removed13[0]).toBeDefined();
     expect(removed13[0].deleted).toBeDefined();
@@ -119,7 +118,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
-    const removed3 = bst.remove(3, true);
+    const removed3 = bst.remove(3);
     expect(removed3).toBeInstanceOf(Array);
     expect(removed3[0]).toBeDefined();
     expect(removed3[0].deleted).toBeDefined();
@@ -127,7 +126,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
-    const removed8 = bst.remove(8, true);
+    const removed8 = bst.remove(8);
     expect(removed8).toBeInstanceOf(Array);
     expect(removed8[0]).toBeDefined();
     expect(removed8[0].deleted).toBeDefined();
@@ -135,16 +134,16 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(true);
     expect(bst.getHeight()).toBe(3);
 
-    const removed6 = bst.remove(6, true);
+    const removed6 = bst.remove(6);
     expect(removed6).toBeInstanceOf(Array);
     expect(removed6[0]).toBeDefined();
     expect(removed6[0].deleted).toBeDefined();
     if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
-    expect(bst.remove(6, true).length).toBe(0);
+    expect(bst.remove(6).length).toBe(0);
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
-    const removed7 = bst.remove(7, true);
+    const removed7 = bst.remove(7);
     expect(removed7).toBeInstanceOf(Array);
     expect(removed7[0]).toBeDefined();
     expect(removed7[0].deleted).toBeDefined();
@@ -152,7 +151,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
-    const removed9 = bst.remove(9, true);
+    const removed9 = bst.remove(9);
     expect(removed9).toBeInstanceOf(Array);
     expect(removed9[0]).toBeDefined();
     expect(removed9[0].deleted).toBeDefined();
@@ -160,7 +159,7 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(3);
 
-    const removed14 = bst.remove(14, true);
+    const removed14 = bst.remove(14);
     expect(removed14).toBeInstanceOf(Array);
     expect(removed14[0]).toBeDefined();
     expect(removed14[0].deleted).toBeDefined();
@@ -168,7 +167,6 @@ describe('Individual package BST operations test', () => {
     expect(bst.isAVLBalanced()).toBe(false);
     expect(bst.getHeight()).toBe(2);
 
-
     expect(bst.isAVLBalanced()).toBe(false);
 
     const bfsIDs = bst.BFS();
@@ -180,21 +178,34 @@ describe('Individual package BST operations test', () => {
     expect(bfsNodes[0].id).toBe(2);
     expect(bfsNodes[1].id).toBe(12);
     expect(bfsNodes[2].id).toBe(16);
-
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<BSTNode<{ id: number, keyA: number }>>();
+    const objBST = new BST<BSTNode<{id: number; keyA: number}>>();
     expect(objBST).toBeInstanceOf(BST);
     objBST.add(11, {id: 11, keyA: 11});
     objBST.add(3, {id: 3, keyA: 3});
-    const values = [{id: 15, keyA: 15}, {id: 1, keyA: 1}, {id: 8, keyA: 8},
-      {id: 13, keyA: 13}, {id: 16, keyA: 16}, {id: 2, keyA: 2},
-      {id: 6, keyA: 6}, {id: 9, keyA: 9}, {id: 12, keyA: 12},
-      {id: 14, keyA: 14}, {id: 4, keyA: 4}, {id: 7, keyA: 7},
-      {id: 10, keyA: 10}, {id: 5, keyA: 5}];
-
-    objBST.addMany(values.map(item => item.id), values);
+    const values = [
+      {id: 15, keyA: 15},
+      {id: 1, keyA: 1},
+      {id: 8, keyA: 8},
+      {id: 13, keyA: 13},
+      {id: 16, keyA: 16},
+      {id: 2, keyA: 2},
+      {id: 6, keyA: 6},
+      {id: 9, keyA: 9},
+      {id: 12, keyA: 12},
+      {id: 14, keyA: 14},
+      {id: 4, keyA: 4},
+      {id: 7, keyA: 7},
+      {id: 10, keyA: 10},
+      {id: 5, keyA: 5}
+    ];
+
+    objBST.addMany(
+      values.map(item => item.id),
+      values
+    );
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -242,7 +253,7 @@ describe('Individual package BST operations test', () => {
     expect(bfsNodesAfterBalanced[0].id).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].id).toBe(16);
 
-    const removed11 = objBST.remove(11, true);
+    const removed11 = objBST.remove(11);
     expect(removed11).toBeInstanceOf(Array);
     expect(removed11[0]).toBeDefined();
     expect(removed11[0].deleted).toBeDefined();
@@ -253,7 +264,7 @@ describe('Individual package BST operations test', () => {
 
     expect(node15 && objBST.getHeight(node15)).toBe(2);
 
-    const removed1 = objBST.remove(1, true);
+    const removed1 = objBST.remove(1);
     expect(removed1).toBeInstanceOf(Array);
     expect(removed1[0]).toBeDefined();
     expect(removed1[0].deleted).toBeDefined();
@@ -263,7 +274,7 @@ describe('Individual package BST operations test', () => {
 
     expect(objBST.getHeight()).toBe(4);
 
-    const removed4 = objBST.remove(4, true);
+    const removed4 = objBST.remove(4);
     expect(removed4).toBeInstanceOf(Array);
     expect(removed4[0]).toBeDefined();
     expect(removed4[0].deleted).toBeDefined();
@@ -271,7 +282,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(4);
 
-    const removed10 = objBST.remove(10, true);
+    const removed10 = objBST.remove(10);
     expect(removed10).toBeInstanceOf(Array);
     expect(removed10[0]).toBeDefined();
     expect(removed10[0].deleted).toBeDefined();
@@ -279,7 +290,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(4);
 
-    const removed15 = objBST.remove(15, true);
+    const removed15 = objBST.remove(15);
     expect(removed15).toBeInstanceOf(Array);
     expect(removed15[0]).toBeDefined();
     expect(removed15[0].deleted).toBeDefined();
@@ -288,7 +299,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed5 = objBST.remove(5, true);
+    const removed5 = objBST.remove(5);
     expect(removed5).toBeInstanceOf(Array);
     expect(removed5[0]).toBeDefined();
     expect(removed5[0].deleted).toBeDefined();
@@ -297,7 +308,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed13 = objBST.remove(13, true);
+    const removed13 = objBST.remove(13);
     expect(removed13).toBeInstanceOf(Array);
     expect(removed13[0]).toBeDefined();
     expect(removed13[0].deleted).toBeDefined();
@@ -305,7 +316,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed3 = objBST.remove(3, true);
+    const removed3 = objBST.remove(3);
     expect(removed3).toBeInstanceOf(Array);
     expect(removed3[0]).toBeDefined();
     expect(removed3[0].deleted).toBeDefined();
@@ -313,7 +324,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed8 = objBST.remove(8, true);
+    const removed8 = objBST.remove(8);
     expect(removed8).toBeInstanceOf(Array);
     expect(removed8[0]).toBeDefined();
     expect(removed8[0].deleted).toBeDefined();
@@ -321,16 +332,16 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(true);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed6 = objBST.remove(6, true);
+    const removed6 = objBST.remove(6);
     expect(removed6).toBeInstanceOf(Array);
     expect(removed6[0]).toBeDefined();
     expect(removed6[0].deleted).toBeDefined();
     if (removed6[0].deleted) expect(removed6[0].deleted.id).toBe(6);
-    expect(objBST.remove(6, true).length).toBe(0);
+    expect(objBST.remove(6).length).toBe(0);
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed7 = objBST.remove(7, true);
+    const removed7 = objBST.remove(7);
     expect(removed7).toBeInstanceOf(Array);
     expect(removed7[0]).toBeDefined();
     expect(removed7[0].deleted).toBeDefined();
@@ -338,7 +349,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed9 = objBST.remove(9, true);
+    const removed9 = objBST.remove(9);
     expect(removed9).toBeInstanceOf(Array);
     expect(removed9[0]).toBeDefined();
     expect(removed9[0].deleted).toBeDefined();
@@ -346,7 +357,7 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(3);
 
-    const removed14 = objBST.remove(14, true);
+    const removed14 = objBST.remove(14);
     expect(removed14).toBeInstanceOf(Array);
     expect(removed14[0]).toBeDefined();
     expect(removed14[0].deleted).toBeDefined();
@@ -354,7 +365,6 @@ describe('Individual package BST operations test', () => {
     expect(objBST.isAVLBalanced()).toBe(false);
     expect(objBST.getHeight()).toBe(2);
 
-
     expect(objBST.isAVLBalanced()).toBe(false);
 
     const bfsIDs = objBST.BFS();
@@ -366,6 +376,5 @@ describe('Individual package BST operations test', () => {
     expect(bfsNodes[0].id).toBe(2);
     expect(bfsNodes[1].id).toBe(12);
     expect(bfsNodes[2].id).toBe(16);
-
   });
 });

package/test/integration/heap.test.js

@@ -12,8 +12,5 @@ describe('JS Heap Operation Test', () => {
     expect(minNumHeap.toArray()[1]).toBe(5);
     expect(minNumHeap.toArray()[2]).toBe(9);
     expect(minNumHeap.toArray()[3]).toBe(6);
-
-
   });
 });
-