data-structure-typed 1.54.2 → 2.0.0

package/test/integration/compile.mjs

@@ -13,28 +13,28 @@ const entries = [
   [8, '8']
 ];
 const queue = new Queue(orgArr);
-queue.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const deque = new Deque(orgArr);
-deque.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const sList = new SinglyLinkedList(orgArr);
-sList.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const dList = new DoublyLinkedList(orgArr);
-dList.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const stack = new Stack(orgArr);
-stack.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const minHeap = new MinHeap(orgArr);
-minHeap.print();
+
 // [1, 5, 2, 7, 6, 3, 4, 9, 8]
 const maxPQ = new MaxPriorityQueue(orgArr);
-maxPQ.print();
+
 // [9, 8, 4, 7, 5, 2, 3, 1, 6]
 const biTree = new BinaryTree(entries);
-biTree.print();
+
 //         ___6___
 //        /       \
 //     ___1_     _2_
@@ -43,7 +43,7 @@ biTree.print();
 //  /   \
 //  9   8
 const bst = new BST(entries);
-bst.print();
+
 //     _____5___
 //    /         \
 //   _2_       _7_
@@ -52,7 +52,7 @@ bst.print();
 //        \         \
 //        4         9
 const rbTree = new RedBlackTree(entries);
-rbTree.print();
+
 //     ___4___
 //    /       \
 //   _2_     _6___
@@ -61,7 +61,7 @@ rbTree.print();
 //              /   \
 //              7   9
 const avl = new AVLTree(entries);
-avl.print();
+
 //     ___4___
 //    /       \
 //   _2_     _6___
@@ -70,7 +70,7 @@ avl.print();
 //              /   \
 //              7   9
 const treeMulti = new TreeMultiMap(entries);
-treeMulti.print();
+
 //     ___4___
 //    /       \
 //   _2_     _6___
@@ -79,10 +79,10 @@ treeMulti.print();
 //              /   \
 //              7   9
 const hm = new HashMap(entries);
-hm.print();
+
 // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
 const rbTreeH = new RedBlackTree(hm);
-rbTreeH.print();
+
 //     ___4___
 //    /       \
 //   _2_     _6___
@@ -91,10 +91,10 @@ rbTreeH.print();
 //              /   \
 //              7   9
 const pq = new MinPriorityQueue(orgArr);
-pq.print();
+
 // [1, 5, 2, 7, 6, 3, 4, 9, 8]
 const bst1 = new BST(pq);
-bst1.print();
+
 //     _____5___
 //    /         \
 //   _2_       _7_
@@ -103,10 +103,10 @@ bst1.print();
 //        \         \
 //        4         9
 const dq1 = new Deque(orgArr);
-dq1.print();
+
 // [6, 1, 2, 7, 5, 3, 4, 9, 8]
 const rbTree1 = new RedBlackTree(dq1);
-rbTree1.print();
+
 //    _____5___
 //   /         \
 //  _2___     _7___
@@ -115,13 +115,13 @@ rbTree1.print();
 //      /         /
 //      3         8
 const trie2 = new Trie(orgStrArr);
-trie2.print();
+
 // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
 const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
-heap2.print();
+
 // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
 const dq2 = new Deque(heap2);
-dq2.print();
+
 // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
 const entries2 = dq2.map((el, i) => [i, el]);
 const avl2 = new AVLTree(entries2);

package/test/performance/data-structures/binary-tree/avl-tree.test.mjs

@@ -0,0 +1,71 @@
+import { AVLTree } from 'data-structure-typed';
+import Benchmark from 'benchmark';
+
+const magnitude = {
+  THOUSAND: 1000,
+  TEN_THOUSAND: 10000,
+  HUNDRED_THOUSAND: 100000,
+  MILLION: 1000000,
+  TEN_MILLION: 10000000,
+  BILLION: 100000000
+};
+
+function getRandomIntArray(length = 1000, min = -1000, max = 1000, unique = true) {
+  if (unique) {
+    if (max - min + 1 < length) {
+      throw new Error('Range too small for unique values with the specified length');
+    }
+    const allNumbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
+    for (let i = allNumbers.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
+    }
+    return allNumbers.slice(0, length);
+  }
+  else {
+    return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min);
+  }
+}
+
+const suite = new Benchmark.Suite();
+const avlTree = new AVLTree();
+const { HUNDRED_THOUSAND } = magnitude;
+const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.get(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.getNode(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+    const entries = [...avlTree];
+    return entries.length === HUNDRED_THOUSAND;
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.add(i);
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.delete(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+    avlTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.add(randomArray[i]);
+    for (let i = 0; i < randomArray.length; i++)
+      avlTree.delete(randomArray[i]);
+  });
+export { suite };

package/test/performance/data-structures/binary-tree/red-black-tree.test.mjs

@@ -0,0 +1,81 @@
+import { RedBlackTree } from 'data-structure-typed';
+import Benchmark from 'benchmark';
+
+const magnitude = {
+  THOUSAND: 1000,
+  TEN_THOUSAND: 10000,
+  HUNDRED_THOUSAND: 100000,
+  MILLION: 1000000,
+  TEN_MILLION: 10000000,
+  BILLION: 100000000
+};
+
+function getRandomIntArray(length = 1000, min = -1000, max = 1000, unique = true) {
+  if (unique) {
+    if (max - min + 1 < length) {
+      throw new Error('Range too small for unique values with the specified length');
+    }
+    const allNumbers = Array.from({ length: max - min + 1 }, (_, i) => i + min);
+    for (let i = allNumbers.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [allNumbers[i], allNumbers[j]] = [allNumbers[j], allNumbers[i]];
+    }
+    return allNumbers.slice(0, length);
+  }
+  else {
+    return Array.from({ length }, () => Math.floor(Math.random() * (max - min + 1)) + min);
+  }
+}
+const suite = new Benchmark.Suite();
+const rbTree = new RedBlackTree();
+const rbTreeNodeMode = new RedBlackTree([], { isMapMode: false });
+const { HUNDRED_THOUSAND } = magnitude;
+const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.get(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.getNode(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
+    rbTreeNodeMode.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      rbTreeNodeMode.add(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
+    for (let i = 0; i < randomArray.length; i++)
+      rbTreeNodeMode.get(randomArray[i]);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+    const entries = [...rbTree];
+    return entries.length === HUNDRED_THOUSAND;
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.add(i);
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.delete(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
+    rbTree.clear();
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.add(randomArray[i]);
+    for (let i = 0; i < randomArray.length; i++)
+      rbTree.delete(randomArray[i]);
+  });
+
+export { suite };

package/test/performance/{reportor.js → reportor.mjs}

@@ -1,15 +1,268 @@
 import * as path from 'path';
 import * as fs from 'fs';
-import * as fastGlob from 'fast-glob';
-import { ConsoleColor, numberFix, render } from '../utils';
+import fastGlob from 'fast-glob';
+import { fileURLToPath } from 'url';
 
+const isNumber = (value) => {
+  return typeof value === 'number';
+};
+const isString = (value) => {
+  return typeof value === 'string';
+};
+const isBoolean = (value) => {
+  return typeof value === 'boolean';
+};
+const isDate = (value) => {
+  return value instanceof Date;
+};
+const isNull = (value) => {
+  return value === null;
+};
+const isUndefined = (value) => {
+  return typeof value === 'undefined';
+};
+const isFunction = (value) => {
+  return typeof value === 'function';
+};
+const isObject = (value) => {
+  return typeof value === 'object';
+};
+const isArray = (value) => {
+  return Array.isArray(value);
+};
+const isEqual = (objA, objB) => {
+  if (objA === objB) {
+    return true;
+  }
+  if (typeof objA !== 'object' || typeof objB !== 'object' || objA === null || objB === null) {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (!keysB.includes(key)) {
+      return false;
+    }
+    if (!isEqual(objA[key], objB[key])) {
+      return false;
+    }
+  }
+  return true;
+};
+
+function toggleJS(options) {
+  if (options === null || options === void 0 ? void 0 : options.plainHtml) {
+    return '';
+  }
+  else {
+    return 'onclick="json-to-html.toggleVisibility(this);return false"';
+  }
+}
+function makeLabelDiv(options, level, keyName, datatype) {
+  if (typeof keyName === 'number') {
+    return `<div class='index'><span class='json-to-html-label'>${keyName}&nbsp;</span></div>`;
+  }
+  else if (typeof keyName === 'string') {
+    if (datatype === 'array') {
+      return `<div class='collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}</span></div>`;
+    }
+    else if (datatype === 'object') {
+      return `<div class='attribute collapsible level${level}' ${toggleJS(options)}><span class='json-to-html-label'>${keyName}:</span></div>`;
+    }
+    else {
+      return `<div class='leaf level${level}'><span class='json-to-html-label'>${keyName}:</span></div>`;
+    }
+  }
+  else {
+    return '';
+  }
+}
+function getContentClass(keyName) {
+  if (typeof keyName === 'string') {
+    return 'content';
+  }
+  else {
+    return '';
+  }
+}
+function isPlainObject(val) {
+  let lastKey;
+  let lastOwnKey;
+  for (const key in val) {
+    if (val.hasOwnProperty(key)) {
+      lastOwnKey = key;
+    }
+  }
+  for (const key in val) {
+    lastKey = key;
+  }
+  return lastOwnKey === lastKey;
+}
+function isLeafValue(val) {
+  return (isNumber(val) ||
+    isString(val) ||
+    isBoolean(val) ||
+    isDate(val) ||
+    isNull(val) ||
+    isUndefined(val) ||
+    isNaN(val) ||
+    isFunction(val) ||
+    !isPlainObject(val));
+}
+function isLeafObject(obj) {
+  if (!isObject(obj)) {
+    return false;
+  }
+  for (const key in obj) {
+    const val = obj[key];
+    if (!isLeafValue(val)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isTable(arr) {
+  if (!isArray(arr)) {
+    return false;
+  }
+  if (arr.length === 0 || !isObject(arr[0])) {
+    return false;
+  }
+  else {
+    let nonCompliant = arr.find(row => !isLeafObject(row));
+    if (nonCompliant) {
+      return false;
+    }
+    else {
+      const cols = Object.keys(arr[0]);
+      nonCompliant = arr.find((row) => !isEqual(cols, Object.keys(row)));
+      return !nonCompliant;
+    }
+  }
+}
+function drawTable(arr) {
+  function drawRow(headers, rowObj) {
+    return '<td>' + headers.map(header => rowObj[header]).join('</td><td>') + '</td>';
+  }
+  const cols = Object.keys(arr[0]);
+  const content = arr.map(rowObj => drawRow(cols, rowObj));
+  const headingHtml = '<tr><th>' + cols.join('</th><th>') + '</th></tr>';
+  const contentHtml = '<tr>' + content.join('</tr><tr>') + '</tr>';
+  return '<table style="display: table; width:100%; table-layout: fixed;">' + headingHtml + contentHtml + '</table>';
+}
+function _render(name, data, options, level, altRow) {
+  const contentClass = getContentClass(name);
+  if (isArray(data)) {
+    const title = makeLabelDiv(options, level, `${name}`, 'array');
+    let subs;
+    if (isTable(data)) {
+      subs = drawTable(data);
+    }
+    else {
+      subs =
+        "<div class='altRows'>" +
+        data
+          .map((val, idx) => _render(idx.toString(), val, options, level + 1, idx % 2))
+          .join("</div><div class='altRows'>") +
+        '</div>';
+    }
+    return `<div class="json-to-html-collapse clearfix ${altRow}">
+      ${title}
+      <div class="${contentClass}">${subs}</div>
+    </div>`;
+  }
+  else if (isLeafValue(data)) {
+    const title = makeLabelDiv(options, level, name);
+    if (isFunction(data)) {
+      return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-function() can't _render-</span>`;
+    }
+    else if (!isPlainObject(data)) {
+      if (isFunction(data.toString)) {
+        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data.toString()}</span>`;
+      }
+      else {
+        return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;-instance object, can't render-</span>`;
+      }
+    }
+    else {
+      return `${title}<span class='json-to-html-value'>&nbsp;&nbsp;${data}</span>`;
+    }
+  }
+  else {
+    const title = makeLabelDiv(options, level, name, 'object');
+    let count = 0;
+    const subs = '<div>' +
+      Object.entries(data)
+        .map(([key, val]) => _render(key, val, options, level + 1, count++ % 2))
+        .join('</div><div>') +
+      '</div>';
+    const inner = `<div class="json-to-html-expand clearfix ${altRow}">
+      ${title}
+      <div class="${contentClass}">${subs}</div>
+    </div>`;
+    return `${level === 0 ? "<div id='json-to-html'>" : ''}
+      ${inner}
+      ${level === 0 ? '</div>' : ''}`;
+  }
+}
+export function render(name, json, options) {
+  return `${_render(name, json, options, 0, 0)}`;
+}
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+function numberFix(num, decimalPlaces) {
+  if (num > 10000 || num < 0.001) {
+    const [mantissa, exponent] = num.toExponential().split('e');
+    const formattedMantissa = Number(mantissa).toFixed(decimalPlaces);
+    return `${formattedMantissa}e${exponent}`;
+  } else {
+    return num.toFixed(decimalPlaces);
+  }
+}
+const ConsoleColor = {
+  END: '\x1b[0m',
+  BOLD: '\x1b[1m',
+  DIM: '\x1b[2m',
+  ITALIC: '\x1b[3m',
+  UNDERLINE: '\x1b[4m',
+  INVERSE: '\x1b[7m',
+  STRIKETHROUGH: '\x1b[9m',
+  NO_BOLD: '\x1b[22m',
+  NO_ITALIC: '\x1b[23m',
+  NO_UNDERLINE: '\x1b[24m',
+  NO_INVERSE: '\x1b[27m',
+  NO_STRIKETHROUGH: '\x1b[29m',
+  BLACK: '\x1b[30m',
+  RED: '\x1b[31m',
+  GREEN: '\x1b[32m',
+  YELLOW: '\x1b[33m',
+  BLUE: '\x1b[34m',
+  MAGENTA: '\x1b[35m',
+  GRAY: '\x1b[90m',
+  CYAN: '\x1b[36m',
+  WHITE: '\x1b[37m',
+  BG_BLACK: '\x1b[40m',
+  BG_RED: '\x1b[41m',
+  BG_GREEN: '\x1b[42m',
+  BG_YELLOW: '\x1b[43m',
+  BG_BLUE: '\x1b[44m',
+  BG_MAGENTA: '\x1b[45m',
+  BG_CYAN: '\x1b[46m',
+  BG_WHITE: '\x1b[47m'
+};
 const args = process.argv.slice(2);
 const { GREEN, BOLD, END, YELLOW, GRAY, CYAN, BG_YELLOW } = ConsoleColor;
 const isOnlyOrdered = true;
 const runOrder = [
   'heap',
   'avl-tree',
-  'rb-tree',
+  'red-black-tree',
   'doubly-linked-list',
   'directed-graph',
   'queue',
@@ -25,6 +278,7 @@ const getRelativePath = file => {
   return path.relative(__dirname, file);
 };
 const coloredLabeled = (label, file) => {
+
   const relativeFilePath = getRelativePath(file);
   const directory = path.dirname(relativeFilePath);
   const fileName = path.basename(relativeFilePath);
@@ -33,7 +287,8 @@ const coloredLabeled = (label, file) => {
 const parentDirectory = path.resolve(__dirname, '../..');
 const reportDistPath = path.join(parentDirectory, 'benchmark');
 const testDir = path.join(__dirname, 'data-structures');
-const allFiles = fastGlob.sync(path.join(testDir, '**', '*.test.js'));
+let allFiles = fastGlob.sync(path.join(testDir, '**', '*.test.mjs'));
+
 let testFiles;
 let isIndividual = false;
 if (args.length > 0) {
@@ -51,9 +306,9 @@ if (args.length > 0) {
 const report = {};
 let completedCount = 0;
 const performanceTests = [];
-testFiles.forEach(file => {
-  const testName = path.basename(file, '.test.ts');
-  const testFunction = require(file);
+for (const file of testFiles) {
+  const testName = path.basename(file, '.test.mjs');
+  const testFunction = await import(file);
   const { suite } = testFunction;
   if (suite)
     performanceTests.push({
@@ -61,7 +316,8 @@ testFiles.forEach(file => {
       suite,
       file
     });
-});
+}
+
 const composeReport = () => {
   if (!fs.existsSync(reportDistPath))
     fs.mkdirSync(reportDistPath, {

package/test/performance/reportor.ts

@@ -12,7 +12,7 @@ const isOnlyOrdered = true;
 const runOrder = [
   'heap',
   'avl-tree',
-  'rb-tree',
+  'red-black-tree',
   'doubly-linked-list',
   'directed-graph',
   'queue',

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

@@ -91,7 +91,7 @@ describe('AVLTreeCounter operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -99,7 +99,7 @@ describe('AVLTreeCounter operations test1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -347,7 +347,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', 15);
+    if (node15) avlCounter.dfs(node => (subTreeSum += node.key), 'PRE', false, 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     avlCounter.lesserOrGreaterTraverse((node: AVLTreeCounterNode<number>) => (lesserSum += node.key), -1, 10);
@@ -355,7 +355,7 @@ describe('AVLTreeCounter operations test recursively1', () => {
 
     expect(node15 instanceof AVLTreeCounterNode);
     if (node15 instanceof AVLTreeCounterNode) {
-      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', 15);
+      const subTreeAdd = avlCounter.dfs(node => (node.count += 1), 'PRE', false, 15);
       expect(subTreeAdd);
     }
     const node11 = avlCounter.getNode(11);
@@ -709,7 +709,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn 2', () => {
@@ -724,7 +724,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 
   it('should toEntryFn throw error', () => {
@@ -760,7 +760,7 @@ describe('AVLTreeCounter toEntryFn', () => {
 
     expect(avlCounter.morris(node => node.key, 'IN')).toEqual(expected);
     expect(avlCounter.dfs(node => node.key, 'IN')).toEqual(expected);
-    expect(avlCounter.dfs(node => node.key, 'IN', avlCounter.root, 'RECURSIVE')).toEqual(expected);
+    expect(avlCounter.dfs(node => node.key, 'IN', false, avlCounter.root, 'RECURSIVE')).toEqual(expected);
   });
 });