data-structure-typed 1.54.2 → 1.54.3

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);
   });
 });
 

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

@@ -50,7 +50,7 @@ describe('AVLTreeMultiMap Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -176,7 +176,7 @@ describe('AVLTreeMultiMap Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -509,7 +509,7 @@ describe('AVLTreeMultiMap not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -527,7 +527,6 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     const avlTmm = new AVLTreeMultiMap<number>([], { iterationType: 'RECURSIVE' });
 
     for (const i of arr) avlTmm.add([i, [i]]);
-
     const node6 = avlTmm.getNode(6);
 
     expect(node6 && avlTmm.getHeight(node6)).toBe(3);
@@ -544,7 +543,7 @@ describe('AVLTreeMultiMap not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTmm.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

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

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode } from '../../../../src';
+import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, Range } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -150,7 +150,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -480,7 +480,7 @@ describe('AVL Tree not map mode', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -515,7 +515,7 @@ describe('AVL Tree not map mode test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', node15);
+    if (node15) avlTree.dfs(node => (subTreeSum += node.key), 'PRE', false, node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -542,3 +542,70 @@ describe('AVLTree iterative methods not map mode', () => {
     expect(cloned.get(cloned.root?.right?.key)).toBe('c');
   });
 });
+
+describe('classic use', () => {
+  // Test case for finding elements in a given range
+  it('@example Find elements in a range', () => {
+    type Datum = { timestamp: Date; temperature: number };
+    // Fixed dataset of CPU temperature readings
+    const cpuData: Datum[] = [
+      { timestamp: new Date('2024-12-02T00:00:00'), temperature: 55.1 },
+      { timestamp: new Date('2024-12-02T00:01:00'), temperature: 56.3 },
+      { timestamp: new Date('2024-12-02T00:02:00'), temperature: 54.8 },
+      { timestamp: new Date('2024-12-02T00:03:00'), temperature: 57.2 },
+      { timestamp: new Date('2024-12-02T00:04:00'), temperature: 58.0 },
+      { timestamp: new Date('2024-12-02T00:05:00'), temperature: 59.4 },
+      { timestamp: new Date('2024-12-02T00:06:00'), temperature: 60.1 },
+      { timestamp: new Date('2024-12-02T00:07:00'), temperature: 61.3 },
+      { timestamp: new Date('2024-12-02T00:08:00'), temperature: 62.0 },
+      { timestamp: new Date('2024-12-02T00:09:00'), temperature: 63.5 },
+      { timestamp: new Date('2024-12-02T00:10:00'), temperature: 64.0 },
+      { timestamp: new Date('2024-12-02T00:11:00'), temperature: 62.8 },
+      { timestamp: new Date('2024-12-02T00:12:00'), temperature: 61.5 },
+      { timestamp: new Date('2024-12-02T00:13:00'), temperature: 60.2 },
+      { timestamp: new Date('2024-12-02T00:14:00'), temperature: 59.8 },
+      { timestamp: new Date('2024-12-02T00:15:00'), temperature: 58.6 },
+      { timestamp: new Date('2024-12-02T00:16:00'), temperature: 57.4 },
+      { timestamp: new Date('2024-12-02T00:17:00'), temperature: 56.2 },
+      { timestamp: new Date('2024-12-02T00:18:00'), temperature: 55.7 },
+      { timestamp: new Date('2024-12-02T00:19:00'), temperature: 54.5 },
+      { timestamp: new Date('2024-12-02T00:20:00'), temperature: 53.2 },
+      { timestamp: new Date('2024-12-02T00:21:00'), temperature: 52.8 },
+      { timestamp: new Date('2024-12-02T00:22:00'), temperature: 51.9 },
+      { timestamp: new Date('2024-12-02T00:23:00'), temperature: 50.5 },
+      { timestamp: new Date('2024-12-02T00:24:00'), temperature: 49.8 },
+      { timestamp: new Date('2024-12-02T00:25:00'), temperature: 48.7 },
+      { timestamp: new Date('2024-12-02T00:26:00'), temperature: 47.5 },
+      { timestamp: new Date('2024-12-02T00:27:00'), temperature: 46.3 },
+      { timestamp: new Date('2024-12-02T00:28:00'), temperature: 45.9 },
+      { timestamp: new Date('2024-12-02T00:29:00'), temperature: 45.0 }
+    ];
+
+    // Create an AVL tree to store CPU temperature data
+    const cpuTemperatureTree = new AVLTree<Date, number, Datum>(cpuData, {
+      toEntryFn: ({ timestamp, temperature }) => [timestamp, temperature]
+    });
+
+    // Query a specific time range (e.g., from 00:05 to 00:15)
+    const rangeStart = new Date('2024-12-02T00:05:00');
+    const rangeEnd = new Date('2024-12-02T00:15:00');
+    const rangeResults = cpuTemperatureTree.rangeSearch([rangeStart, rangeEnd], node => ({
+      minute: node ? node.key.getMinutes() : 0,
+      temperature: cpuTemperatureTree.get(node ? node.key : undefined)
+    }));
+
+    expect(rangeResults).toEqual( [
+            { minute: 5, temperature: 59.4 },
+            { minute: 6, temperature: 60.1 },
+            { minute: 7, temperature: 61.3 },
+            { minute: 8, temperature: 62 },
+            { minute: 9, temperature: 63.5 },
+            { minute: 10, temperature: 64 },
+            { minute: 11, temperature: 62.8 },
+            { minute: 12, temperature: 61.5 },
+            { minute: 13, temperature: 60.2 },
+            { minute: 14, temperature: 59.8 },
+            { minute: 15, temperature: 58.6 }
+          ]);
+  });
+});