data-structure-typed 1.36.7 → 1.36.9

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

@@ -1,4 +1,5 @@
-import {MaxHeap, MinHeap} from '../../../../src';
+import {FibonacciHeap, MaxHeap, MinHeap} from '../../../../src';
+import {logBigOMetricsWrap} from '../../../utils';
 
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
@@ -60,3 +61,193 @@ describe('Heap Operation Test', () => {
     }
   });
 });
+
+describe('FibonacciHeap', () => {
+  let heap: FibonacciHeap<number>;
+
+  beforeEach(() => {
+    heap = new FibonacciHeap<number>();
+  });
+
+  test('push & peek', () => {
+    heap.push(10);
+    heap.push(5);
+    expect(heap.peek()).toBe(5);
+  });
+
+  test('pop', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+    expect(heap.pop()).toBe(5);
+    expect(heap.pop()).toBe(10);
+    expect(heap.pop()).toBe(15);
+  });
+
+  test('pop on an empty heap', () => {
+    expect(heap.pop()).toBeUndefined();
+  });
+
+  test('size', () => {
+    expect(heap.size).toBe(0);
+    heap.push(10);
+    expect(heap.size).toBe(1);
+    heap.pop();
+    expect(heap.size).toBe(0);
+  });
+
+  test('clear', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.clear();
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  test('custom comparator', () => {
+    const maxHeap = new FibonacciHeap<number>((a, b) => b - a);
+    maxHeap.push(10);
+    maxHeap.push(5);
+    expect(maxHeap.peek()).toBe(10);
+  });
+});
+
+describe('FibonacciHeap', () => {
+  let heap: FibonacciHeap<number>;
+
+  beforeEach(() => {
+    heap = new FibonacciHeap<number>();
+  });
+
+  it('should initialize an empty heap', () => {
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  it('should push items into the heap and update size', () => {
+    heap.push(10);
+    heap.push(5);
+
+    expect(heap.size).toBe(2);
+  });
+
+  it('should peek the minimum item', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+
+    expect(heap.peek()).toBe(5);
+  });
+
+  it('should pop the minimum item and update size', () => {
+    heap.push(10);
+    heap.push(5);
+    heap.push(15);
+
+    const minItem = heap.pop();
+
+    expect(minItem).toBe(5);
+    expect(heap.size).toBe(2);
+  });
+
+  it('should correctly merge two heaps', () => {
+    const heap1 = new FibonacciHeap<number>();
+    const heap2 = new FibonacciHeap<number>();
+
+    heap1.push(10);
+    heap2.push(5);
+
+    heap1.merge(heap2);
+
+    expect(heap1.size).toBe(2);
+    expect(heap1.peek()).toBe(5);
+  });
+
+  it('should clear the heap', () => {
+    heap.push(10);
+    heap.push(5);
+
+    heap.clear();
+
+    expect(heap.size).toBe(0);
+    expect(heap.peek()).toBeUndefined();
+  });
+
+  it('should handle custom comparators', () => {
+    const customComparator = (a: number, b: number) => b - a;
+    const customHeap = new FibonacciHeap<number>(customComparator);
+
+    customHeap.push(10);
+    customHeap.push(5);
+    customHeap.push(15);
+
+    expect(customHeap.peek()).toBe(15);
+  });
+
+  describe('FibonacciHeap Merge', () => {
+    it('should merge two Fibonacci heaps correctly', () => {
+      const heap1 = new FibonacciHeap<number>();
+      heap1.push(5).push(10);
+
+      const heap2 = new FibonacciHeap<number>();
+      heap2.push(3).push(7);
+
+      heap1.merge(heap2);
+
+      expect(heap1.size).toBe(4); // Combined size of both heaps
+      expect(heap2.size).toBe(0); // Merged heap should be empty
+      expect(heap1.peek()).toBe(3); // Minimum element should be 3
+    });
+  });
+});
+
+describe('FibonacciHeap Stress Test', () => {
+  it('should handle a large number of elements efficiently', () => {
+    const testByMagnitude = (magnitude: number) => {
+      const heap = new FibonacciHeap<number>();
+
+      // Add 1000 elements to the heap
+      for (let i = 1; i <= magnitude; i++) {
+        heap.push(i);
+      }
+
+      // Verify that the minimum element is 1 (smallest element)
+      expect(heap.peek()).toBe(1);
+
+      // Remove all 1000 elements from the heap
+      const elements = [];
+      while (heap.size > 0) {
+        elements.push(heap.pop());
+      }
+
+      // Verify that all elements were removed in ascending order
+      for (let i = 1; i <= magnitude; i++) {
+        expect(elements[i - 1]).toBe(i);
+      }
+
+      // Verify that the heap is now empty
+      expect(heap.size).toBe(0);
+    };
+
+    testByMagnitude(1000);
+
+    // [
+    //   10, 100, 1000, 5000, 10000, 20000, 50000, 75000, 100000,
+    //   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'
+      )
+    );
+  });
+});

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

@@ -0,0 +1,199 @@
+import {AnyFunction} from '../types';
+
+const orderReducedBy = 2; // reduction of bigO's order compared to the baseline bigO
+
+export const magnitude = {
+  CONSTANT: Math.floor(Number.MAX_SAFE_INTEGER / Math.pow(10, orderReducedBy)),
+  LOG_N: Math.pow(10, 9 - orderReducedBy),
+  LINEAR: Math.pow(10, 6 - orderReducedBy),
+  N_LOG_N: Math.pow(10, 5 - orderReducedBy),
+  SQUARED: Math.pow(10, 4 - orderReducedBy),
+  CUBED: Math.pow(10, 3 - orderReducedBy),
+  FACTORIAL: 20 - orderReducedBy
+};
+
+export const bigO = {
+  CONSTANT: magnitude.CONSTANT / 100000,
+  LOG_N: Math.log2(magnitude.LOG_N) / 1000,
+  LINEAR: magnitude.LINEAR / 1000,
+  N_LOG_N: (magnitude.N_LOG_N * Math.log2(magnitude.LOG_N)) / 1000,
+  SQUARED: Math.pow(magnitude.SQUARED, 2) / 1000,
+  CUBED: Math.pow(magnitude.SQUARED, 3) / 1000,
+  FACTORIAL: 10000
+};
+
+function findPotentialN(input: any): number {
+  let longestArray: any[] = [];
+  let mostProperties: {[key: string]: any} = {};
+
+  function recurse(obj: any) {
+    if (Array.isArray(obj)) {
+      if (obj.length > longestArray.length) {
+        longestArray = obj;
+      }
+    } else if (typeof obj === 'object' && obj !== null) {
+      const keys = Object.keys(obj);
+      if (keys.length > Object.keys(mostProperties).length) {
+        mostProperties = obj;
+      }
+      keys.forEach(key => {
+        recurse(obj[key]);
+      });
+    }
+  }
+
+  if (Array.isArray(input)) {
+    input.forEach(item => {
+      recurse(item);
+    });
+  } else {
+    recurse(input);
+  }
+
+  // return [longestArray, mostProperties] : [any[], { [key: string]: any }];
+  return Math.max(longestArray.length, Object.keys(mostProperties).length);
+}
+
+function linearRegression(x: number[], y: number[]) {
+  const n = x.length;
+
+  const sumX = x.reduce((acc, val) => acc + val, 0);
+  const sumY = y.reduce((acc, val) => acc + val, 0);
+
+  const sumXSquared = x.reduce((acc, val) => acc + val ** 2, 0);
+  const sumXY = x.reduce((acc, val, i) => acc + val * y[i], 0);
+
+  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 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 rSquared = 1 - totalVariation / explainedVariation;
+
+  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 'Lengths of input arrays do not match';
+  }
+
+  // Create an array to store the computational complexity of each data point
+  const complexities: 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
+  ];
+
+  for (const complexity of complexitiesToCheck) {
+    // 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)') {
+        return Math.log(size);
+      } else if (complexity === 'O(n)') {
+        return size;
+      } else if (complexity === 'O(n log n)') {
+        return size * Math.log(size);
+      } else if (complexity === 'O(n^2)') {
+        return size ** 2;
+      } else {
+        return size ** 10;
+      }
+    });
+
+    // 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.
+    if (regressionResult.rSquared >= 0.9) {
+      complexities.push(complexity);
+    }
+  }
+
+  // If there is no valid fitting result, return "cannot estimate", otherwise return the estimated time complexity
+  if (complexities.length === 0) {
+    return 'Unable to estimate';
+  } else {
+    return complexities.join(' or ');
+  }
+}
+
+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;
+
+  descriptor.value = function (...args: any[]) {
+    const startTime = performance.now();
+    const result = originalMethod.apply(this, args);
+    const endTime = performance.now();
+    const runTime = endTime - startTime;
+
+    const methodName = `${target.constructor.name}.${propertyKey}`;
+    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;
+  };
+
+  return descriptor;
+}

package/test/utils/index.ts

@@ -1,2 +1,2 @@
 export * from './number';
-export * from './magnitude';
+export * from './big-o';