data-structure-typed 1.36.8 → 1.36.9

package/test/unit/data-structures/heap/heap.test.ts

@@ -1,5 +1,5 @@
 import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
-import {logBigOMetricsWrap} from "../../../utils";
+import {logBigOMetricsWrap} from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -201,10 +201,8 @@ describe('FibonacciHeap', () => {
   });
 });
 
-
 describe('FibonacciHeap Stress Test', () => {
   it('should handle a large number of elements efficiently', () => {
-
     const testByMagnitude = (magnitude: number) => {
       const heap = new FibonacciHeap<number>();
 
@@ -229,7 +227,7 @@ describe('FibonacciHeap Stress Test', () => {
 
       // Verify that the heap is now empty
       expect(heap.size).toBe(0);
-    }
+    };
 
     testByMagnitude(1000);
 
@@ -238,13 +236,18 @@ describe('FibonacciHeap Stress Test', () => {
     //   150000, 200000, 250000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000
     // ].forEach(m => logBigOMetricsWrap<typeof testByMagnitude>(testByMagnitude, [m]));
     [
-      10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000,
-      150000, 200000, 250000, 300000, 400000, 500000, 600000, 700000, 800000, 900000, 1000000
-    ].forEach(m => logBigOMetricsWrap((c: number) => {
-      const result: number[] = [];
-      for (let i = 0; i < c; i++) result.push(i);
-      return result;
-    } , [m], 'loopPush'));
-
+      10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000, 150000, 200000, 250000, 300000, 400000, 500000, 600000,
+      700000, 800000, 900000, 1000000
+    ].forEach(m =>
+      logBigOMetricsWrap(
+        (c: number) => {
+          const result: number[] = [];
+          for (let i = 0; i < c; i++) result.push(i);
+          return result;
+        },
+        [m],
+        'loopPush'
+      )
+    );
   });
 });

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

@@ -18,7 +18,7 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('pop', () => {
-    it('should remove and return the last element of the list', () => {
+    it('should delete and return the last element of the list', () => {
       list.push(1);
       list.push(2);
       const popped = list.pop();
@@ -33,7 +33,7 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('shift', () => {
-    it('should remove and return the first element of the list', () => {
+    it('should delete and return the first element of the list', () => {
       list.push(1);
       list.push(2);
       const shifted = list.shift();
@@ -109,7 +109,7 @@ describe('SinglyLinkedList Operation Test', () => {
   });
 
   describe('removeValue', () => {
-    it('should remove the first occurrence of a value from the list', () => {
+    it('should delete the first occurrence of a value from the list', () => {
       list.push(1);
       list.push(2);
       list.push(3);
@@ -240,8 +240,8 @@ describe('SinglyLinkedList Operation Test', () => {
     });
   });
 
-  describe('remove', () => {
-    it('should remove and return the element at the specified index', () => {
+  describe('delete', () => {
+    it('should delete and return the element at the specified index', () => {
       list.push(1);
       list.push(2);
       list.push(3);
@@ -256,7 +256,7 @@ describe('SinglyLinkedList Operation Test', () => {
       expect(removed).toBeUndefined();
     });
 
-    it('should remove and return the first element', () => {
+    it('should delete and return the first element', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(0);
@@ -264,7 +264,7 @@ describe('SinglyLinkedList Operation Test', () => {
       expect(list.toArray()).toEqual([2]);
     });
 
-    it('should remove and return the last element', () => {
+    it('should delete and return the last element', () => {
       list.push(1);
       list.push(2);
       const removed = list.deleteAt(1);

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

@@ -25,12 +25,12 @@ describe('SkipList', () => {
     expect(skipList.get(0)).toBeUndefined();
   });
 
-  it('should remove elements correctly', () => {
+  it('should delete elements correctly', () => {
     skipList.add(1, 'One');
     skipList.add(2, 'Two');
     skipList.add(3, 'Three');
 
-    skipList.remove(2);
+    skipList.delete(2);
 
     expect(skipList.get(2)).toBeUndefined(); // 修改这里的断言
   });

package/test/unit/data-structures/priority-queue/max-priority-queue.test.ts

@@ -27,7 +27,7 @@ describe('MaxPriorityQueue Operation Test', () => {
     expect(priorityQueue.poll()?.keyA).toBe(1);
   });
 
-  it('should return and remove the smallest element', () => {
+  it('should return and delete the smallest element', () => {
     const priorityQueue = new MaxPriorityQueue<number>();
     priorityQueue.add(5);
     priorityQueue.add(3);

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

@@ -16,7 +16,7 @@ describe('Deque Tests', () => {
       expect(deque.peekLast()).toBe(2);
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
       deque.pollFirst();
@@ -69,7 +69,7 @@ describe('Deque Tests', () => {
       expect(objectDeque.peekLast()).toBe('two');
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       objectDeque.addFirst('one');
       objectDeque.addLast('two');
       objectDeque.pollFirst();
@@ -106,7 +106,7 @@ describe('Deque Tests', () => {
       expect(arrayDeque.peekLast()).toBe(2);
     });
 
-    it('should remove elements from the beginning and end', () => {
+    it('should delete elements from the beginning and end', () => {
       arrayDeque.addFirst(1);
       arrayDeque.addLast(2);
       arrayDeque.pollFirst();

package/test/unit/data-structures/trie/trie.test.ts

@@ -81,15 +81,15 @@ describe('Trie', () => {
     expect(words).toEqual(['apple', 'application', 'app']);
   });
 
-  it('should remove words from Trie', () => {
+  it('should delete words from Trie', () => {
     const trie = new Trie();
     trie.add('apple');
     trie.add('app');
     expect(trie.has('apple')).toBe(true);
-    trie.remove('apple');
+    trie.delete('apple');
     expect(trie.has('apple')).toBe(false);
     expect(trie.has('app')).toBe(true);
-    trie.remove('app');
+    trie.delete('app');
     expect(trie.has('app')).toBe(false);
   });
 
@@ -772,9 +772,9 @@ describe('Trie operations', () => {
   test('Remove Words', () => {
     trie.add('apple');
     trie.add('banana');
-    expect(trie.remove('apple')).toBe(true);
+    expect(trie.delete('apple')).toBe(true);
     expect(trie.has('apple')).toBe(false);
-    expect(trie.remove('cherry')).toBe(false);
+    expect(trie.delete('cherry')).toBe(false);
   });
 
   test('Case Sensitivity', () => {

package/test/utils/big-o.ts

@@ -1,4 +1,4 @@
-import {AnyFunction} from "../types";
+import {AnyFunction} from '../types';
 
 const orderReducedBy = 2; // reduction of bigO's order compared to the baseline bigO
 
@@ -24,7 +24,7 @@ export const bigO = {
 
 function findPotentialN(input: any): number {
   let longestArray: any[] = [];
-  let mostProperties: { [key: string]: any } = {};
+  let mostProperties: {[key: string]: any} = {};
 
   function recurse(obj: any) {
     if (Array.isArray(obj)) {
@@ -36,14 +36,14 @@ function findPotentialN(input: any): number {
       if (keys.length > Object.keys(mostProperties).length) {
         mostProperties = obj;
       }
-      keys.forEach((key) => {
+      keys.forEach(key => {
         recurse(obj[key]);
       });
     }
   }
 
   if (Array.isArray(input)) {
-    input.forEach((item) => {
+    input.forEach(item => {
       recurse(item);
     });
   } else {
@@ -66,20 +66,20 @@ function linearRegression(x: number[], y: number[]) {
   const slope = (n * sumXY - sumX * sumY) / (n * sumXSquared - sumX ** 2);
   const intercept = (sumY - slope * sumX) / n;
 
-  const yHat = x.map((val) => slope * val + intercept);
+  const yHat = x.map(val => slope * val + intercept);
 
   const totalVariation = y.map((val, i) => (val - yHat[i]) ** 2).reduce((acc, val) => acc + val, 0);
-  const explainedVariation = y.map((val) => (val - (sumY / n)) ** 2).reduce((acc, val) => acc + val, 0);
+  const explainedVariation = y.map(val => (val - sumY / n) ** 2).reduce((acc, val) => acc + val, 0);
 
   const rSquared = 1 - totalVariation / explainedVariation;
 
-  return { slope, intercept, rSquared };
+  return {slope, intercept, rSquared};
 }
 
 function estimateBigO(runtimes: number[], dataSizes: number[]): string {
   // Make sure the input runtimes and data sizes have the same length
   if (runtimes.length !== dataSizes.length) {
-    return "输入数组的长度不匹配";
+    return 'Lengths of input arrays do not match';
   }
 
   // Create an array to store the computational complexity of each data point
@@ -87,32 +87,32 @@ function estimateBigO(runtimes: number[], dataSizes: number[]): string {
 
   // Traverse different possible complexities
   const complexitiesToCheck: string[] = [
-   "O(1)", // constant time complexity
-    "O(log n)", // Logarithmic time complexity
-    "O(n)", // linear time complexity
-    "O(n log n)", // linear logarithmic time complexity
-    "O(n^2)", // squared time complexity
+    'O(1)', // constant time complexity
+    'O(log n)', // Logarithmic time complexity
+    'O(n)', // linear time complexity
+    'O(n log n)', // linear logarithmic time complexity
+    'O(n^2)' // squared time complexity
   ];
 
   for (const complexity of complexitiesToCheck) {
-   // Calculate data points for fitting
-    const fittedData: number[] = dataSizes.map((size) => {
-      if (complexity === "O(1)") {
+    // Calculate data points for fitting
+    const fittedData: number[] = dataSizes.map(size => {
+      if (complexity === 'O(1)') {
         return 1; // constant time complexity
-      } else if (complexity === "O(log n)") {
+      } else if (complexity === 'O(log n)') {
         return Math.log(size);
-      } else if (complexity === "O(n)") {
+      } else if (complexity === 'O(n)') {
         return size;
-      } else if (complexity === "O(n log n)") {
+      } else if (complexity === 'O(n log n)') {
         return size * Math.log(size);
-      } else if (complexity === "O(n^2)") {
+      } else if (complexity === 'O(n^2)') {
         return size ** 2;
       } else {
-        return size ** 10
+        return size ** 10;
       }
     });
 
-   // Fit the data points using linear regression analysis
+    // Fit the data points using linear regression analysis
     const regressionResult = linearRegression(fittedData, runtimes);
 
     // Check the R-squared value of the fit. It is usually considered a valid fit if it is greater than 0.9.
@@ -123,13 +123,43 @@ function estimateBigO(runtimes: number[], dataSizes: number[]): string {
 
   // If there is no valid fitting result, return "cannot estimate", otherwise return the estimated time complexity
   if (complexities.length === 0) {
-    return "Unable to estimate";
+    return 'Unable to estimate';
   } else {
-    return complexities.join(" or ");
+    return complexities.join(' or ');
   }
 }
 
-const methodLogs: Map<string, [number, number][] > = new Map();
+const methodLogs: Map<string, [number, number][]> = new Map();
+
+export function logBigOMetricsWrap<F extends AnyFunction>(fn: F, args: Parameters<F>, fnName: string) {
+  const startTime = performance.now();
+  const result = fn(args);
+  const endTime = performance.now();
+  const runTime = endTime - startTime;
+  const methodName = `${fnName}`;
+  if (!methodLogs.has(methodName)) {
+    methodLogs.set(methodName, []);
+  }
+
+  const methodLog = methodLogs.get(methodName);
+
+  const maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
+  if (methodLog) {
+    methodLog.push([runTime, maxDataSize]);
+
+    if (methodLog.length >= 20) {
+      console.log('triggered', methodName, methodLog);
+      const bigO = estimateBigO(
+        methodLog.map(([runTime]) => runTime),
+        methodLog.map(([runTime]) => runTime)
+      );
+      console.log(`Estimated Big O: ${bigO}`);
+      methodLogs.delete(methodName);
+    }
+  }
+
+  return result;
+}
 
 export function logBigOMetrics(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
   const originalMethod = descriptor.value;
@@ -147,15 +177,18 @@ export function logBigOMetrics(target: any, propertyKey: string, descriptor: Pro
 
     const methodLog = methodLogs.get(methodName);
 
-    const maxDataSize = args.length === 1 && typeof args[0] === "number" ? args[0] : findPotentialN(args);
+    const maxDataSize = args.length === 1 && typeof args[0] === 'number' ? args[0] : findPotentialN(args);
     if (methodLog) {
       methodLog.push([runTime, maxDataSize]);
 
       if (methodLog.length >= 20) {
         console.log('triggered', methodName, methodLog);
-        const bigO = estimateBigO(methodLog.map(([runTime,]) => runTime), methodLog.map(([runTime,]) => runTime));
+        const bigO = estimateBigO(
+          methodLog.map(([runTime]) => runTime),
+          methodLog.map(([runTime]) => runTime)
+        );
         console.log(`Estimated Big O: ${bigO}`);
-        methodLogs.delete(methodName)
+        methodLogs.delete(methodName);
       }
     }
 
@@ -164,30 +197,3 @@ export function logBigOMetrics(target: any, propertyKey: string, descriptor: Pro
 
   return descriptor;
 }
-
-export function logBigOMetricsWrap<F extends AnyFunction>(fn: F, args: Parameters<F>, fnName: string) {
-    const startTime = performance.now();
-    const result = fn(args);
-    const endTime = performance.now();
-    const runTime = endTime - startTime;
-    const methodName = `${fnName}`;
-    if (!methodLogs.has(methodName)) {
-      methodLogs.set(methodName, []);
-    }
-
-    const methodLog = methodLogs.get(methodName);
-
-    const maxDataSize = args.length === 1 && typeof args[0] === "number" ? args[0] : findPotentialN(args);
-    if (methodLog) {
-      methodLog.push([runTime, maxDataSize]);
-
-      if (methodLog.length >= 20) {
-        console.log('triggered', methodName, methodLog);
-        const bigO = estimateBigO(methodLog.map(([runTime,]) => runTime), methodLog.map(([runTime,]) => runTime));
-        console.log(`Estimated Big O: ${bigO}`);
-        methodLogs.delete(methodName)
-      }
-    }
-
-    return result;
-}