data-structure-typed 1.37.4 → 1.37.5

package/src/types/data-structures/hash/hash-table.ts

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

package/src/types/data-structures/hash/tree-map.ts

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

package/src/types/data-structures/hash/tree-set.ts

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

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

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

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

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

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

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

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

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

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

@@ -1,17 +1,11 @@
 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 './rb-tree';
-export * from './directed-graph';
+export * from './graph';
+export * from './linked-list';
 export * from './heap';
-export * from './singly-linked-list';
-export * from './doubly-linked-list';
-export * from './navigator';
+export * from './matrix';
 export * from './hash';
-
-export type MapCallback<N> = (node: N) => any;
-export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;
+export * from './priority-queue';
+export * from './queue';
+export * from './stack';
+export * from './tree';
+export * from './trie';

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

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

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

@@ -0,0 +1,2 @@
+export * from './singly-linked-list';
+export * from './doubly-linked-list';

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

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

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

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

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

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

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

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

package/src/types/data-structures/matrix/matrix2d.ts

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

package/src/types/data-structures/matrix/vector2d.ts

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

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

@@ -0,0 +1,3 @@
+export * from './priority-queue';
+export * from './min-priority-queue';
+export * from './max-priority-queue';

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './deque';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/types/helpers.ts

@@ -1,4 +1,7 @@
 export type Comparator<T> = (a: T, b: T) => number;
 
-// export enum DFSOrderPattern {'pre' = 'pre', 'in' = 'in', 'post' = 'post'}
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
+
+export type MapCallback<N> = (node: N) => any;
+
+export type MapCallbackReturn<N> = ReturnType<MapCallback<N>>;

package/src/utils/utils.ts

@@ -77,3 +77,10 @@ export const trampolineAsync = (fn: TrlAsyncFn) => {
     {cont}
   );
 };
+
+export const getMSB = (value: number): number => {
+  if (value <= 0) {
+    return 0;
+  }
+  return 1 << (31 - Math.clz32(value));
+};

package/test/config.js

@@ -0,0 +1,4 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});
+exports.isDebugTest = void 0;
+exports.isDebugTest = false;

package/test/types/index.js

@@ -0,0 +1,29 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', {value: true});
+__exportStar(require('./utils'), exports);

package/test/types/utils/big-o.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', {value: true});

package/test/types/utils/index.js

@@ -0,0 +1,29 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            }
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', {value: true});
+__exportStar(require('./big-o'), exports);

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

@@ -0,0 +1,284 @@
+import {BinaryIndexedTree} from '../../../../src';
+import {isDebugTest} from '../../../config';
+
+const isDebug = isDebugTest;
+
+describe('BinaryIndexedTree simple', () => {
+  let bit: BinaryIndexedTree;
+
+  beforeEach(() => {
+    //Create a new BinaryIndexedTree instance before each test case
+    bit = new BinaryIndexedTree({frequency: 0, max: 10}); // Modify the value of max as needed
+  });
+
+  it('should initialize correctly', () => {
+    expect(bit.freq).toBe(0);
+    expect(bit.max).toBe(10);
+    expect(bit.freqMap).toEqual({0: 0}); // Modify the initialized record value according to the actual situation
+    // More initialization checks can be added
+  });
+
+  it('should read a single value correctly', () => {
+    // Test the function of reading a single value
+    bit.writeSingle(5, 5); //Write test data
+    expect(bit.readSingle(5)).toBe(5); // Read and verify
+  });
+
+  it('should update a value correctly', () => {
+    // Test the ability to update a single value
+    bit.writeSingle(5, 5); //Write test data
+    bit.update(5, 2); // update value
+    expect(bit.readSingle(5)).toBe(7); // Verify the updated value
+  });
+
+  it('should find lower bound correctly', () => {
+    //Test the function of finding the lower bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.lowerBound(15)).toBe(5); // Find and verify the lower bound
+  });
+
+  it('should find upper bound correctly', () => {
+    //Test the function of finding the upper bound
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.upperBound(25)).toBe(5); // Find and verify the upper bound
+  });
+});
+
+describe('BinaryIndexedTree', () => {
+  const frequency = 999;
+  const max = 10;
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({frequency, max});
+  });
+  it('should validate the index', function () {
+    expect(() => bit.readSingle(-1)).toThrow('Index out of range');
+    expect(() => bit.readSingle(10)).toThrow('Index out of range');
+  });
+
+  it('should read a single frequency correctly', function () {
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.update(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.update(10, 100)).toThrow('Index out of range');
+  });
+  it('should frequency and max', function () {
+    const frequency = 200;
+    const max = 1000;
+    const bit = new BinaryIndexedTree({frequency, max});
+
+    expect(bit.freq).toBe(frequency);
+    expect(bit.max).toBe(max);
+  });
+
+  it('should update the frequency with the given delta', function () {
+    for (let i = 0; i < max; i++) {
+      bit.update(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2 + frequency);
+    }
+  });
+  it('should validate the index', function () {
+    expect(() => bit.writeSingle(-1, 100)).toThrow('Index out of range');
+    expect(() => bit.writeSingle(10, 100)).toThrow('Index out of range');
+  });
+
+  it('should writeSingle to be correctly invoked', function () {
+    for (let i = 0; i < max; i++) {
+      bit.writeSingle(i, i * 2);
+    }
+    for (let i = 0; i < max; i++) {
+      expect(bit.readSingle(i)).toBe(i * 2);
+    }
+  });
+
+  it('should read the frequency', function () {
+    for (let c = 0; c <= max; c++) {
+      expect(bit.read(c)).toBe(c * frequency);
+    }
+  });
+
+  const values = [-5, 0, 5, 10, 95, 100, 1000];
+  it('should find the upper-bound index', function () {
+    loopUpperBoundTests(bit, values);
+  });
+
+  it('should find the lower-bound index', function () {
+    loopLowerBoundTests(bit, values);
+  });
+});
+
+describe('designated values', function () {
+  const array = [1, 8, 6, 10, 7, 9, 0, 2, 6, 3];
+  const sumArray = (sum => array.map(value => (sum += value)))(0);
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  describe('readSingle', function () {
+    it('should read a single frequency correctly', function () {
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i]);
+      });
+    });
+  });
+
+  describe('update', function () {
+    it('should update the frequency with the given delta', function () {
+      array.forEach((value, i) => bit.update(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] * 2 + i);
+      });
+    });
+  });
+
+  describe('writeSingle', function () {
+    it('should write a single frequency correctly', function () {
+      array.forEach((value, i) => bit.writeSingle(i, value + i));
+      array.forEach((value, i) => {
+        expect(bit.readSingle(i)).toBe(array[i] + i);
+      });
+    });
+  });
+
+  describe('read', function () {
+    it('should read the cumulative frequency correctly', function () {
+      expect(bit.read(0)).toBe(0);
+      sumArray.forEach((sum, i) => {
+        expect(bit.read(i + 1)).toBe(sum);
+      });
+    });
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should find the upper-bound index', function () {
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('lowerBound', function () {
+    it('should find the lower-bound index', function () {
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('descending sequence', function () {
+  const array = [1, 8, -6, 10, 7, 9, 0, -2, 6, 3];
+  let bit: BinaryIndexedTree;
+
+  beforeEach(function () {
+    bit = new BinaryIndexedTree({max: array.length});
+    array.forEach((value, i) => bit.writeSingle(i, value));
+  });
+
+  it('should have a correct negativeCount property', function () {
+    expect(bit.negativeCount).toBe(2);
+    bit.update(2, 6);
+    expect(bit.negativeCount).toBe(1);
+    bit.update(7, 3);
+    expect(bit.negativeCount).toBe(0);
+    bit.update(8, -7);
+    expect(bit.negativeCount).toBe(1);
+  });
+
+  const values = [-5, 0, 15, 25, 43, 53, 100];
+
+  describe('upperBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.upperBound(20)).toThrow('Must not be descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopUpperBoundTests(bit, values);
+    });
+  });
+
+  describe('BinaryIndexedTree lowerBound', function () {
+    it('should validate the non-descending', function () {
+      expect(() => bit.lowerBound(20)).toThrow('Sequence is not non-descending');
+      bit.update(2, 12);
+      bit.update(7, 4);
+      loopLowerBoundTests(bit, values);
+    });
+  });
+});
+
+describe('BinaryIndexedTree additional tests', () => {
+  it('should handle read method correctly', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.writeSingle(5, 20);
+    bit.writeSingle(8, 30);
+    expect(bit.read(5)).toBe(10); // Ensure read method accumulates correctly
+  });
+
+  it('should handle consecutive operations', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(2, 10);
+    bit.update(2, 5);
+    expect(bit.readSingle(2)).toBe(15);
+    bit.writeSingle(5, 20);
+    expect(bit.readSingle(5)).toBe(20);
+    expect(bit.lowerBound(15)).toBe(2);
+  });
+
+  it('should handle frequent increment updates', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    for (let i = 0; i < 10; i++) {
+      bit.update(2, 5);
+    }
+    expect(bit.readSingle(2)).toBe(50);
+  });
+
+  it('should handle edge cases', () => {
+    const bit = new BinaryIndexedTree({max: 10});
+    bit.writeSingle(9, 100);
+    expect(bit.readSingle(9)).toBe(100);
+    expect(bit.lowerBound(200)).toBe(10);
+  });
+});
+function loopUpperBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.upperBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThanOrEqual(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThan(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}
+
+function loopLowerBoundTests(bit: BinaryIndexedTree, values: number[]) {
+  for (const value of values) {
+    const index = bit.lowerBound(value);
+    if (index > 0) {
+      expect(bit.read(index)).toBeLessThan(value);
+    } else {
+      expect(index).toBe(0);
+    }
+    if (index < bit.max) {
+      expect(bit.read(index + 1)).toBeGreaterThanOrEqual(value);
+    } else {
+      expect(index).toBe(bit.max);
+    }
+  }
+}