linked-list-typed 1.49.4 → 1.49.5

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

@@ -5,23 +5,452 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-// todo need to be improved
-export class MatrixNTI2D<V = any> {
-  protected readonly _matrix: Array<Array<V>>;
 
+export class Matrix {
   /**
-   * The constructor creates a matrix with the specified number of rows and columns, and initializes all elements to a
-   * given initial value or 0 if not provided.
-   * @param options - An object containing the following properties:
+   * The constructor function initializes a matrix object with the provided data and options, or with
+   * default values if no options are provided.
+   * @param {number[][]} data - A 2D array of numbers representing the data for the matrix.
+   * @param [options] - The `options` parameter is an optional object that can contain the following
+   * properties:
    */
-  constructor(options: { row: number; col: number; initialVal?: V }) {
-    const { row, col, initialVal } = options;
-    this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
+  constructor(
+    data: number[][],
+    options?: {
+      rows?: number;
+      cols?: number;
+      addFn?: (a: number, b: number) => any;
+      subtractFn?: (a: number, b: number) => any;
+      multiplyFn?: (a: number, b: number) => any;
+    }
+  ) {
+    if (options) {
+      const { rows, cols, addFn, subtractFn, multiplyFn } = options;
+      if (typeof rows === 'number' && rows > 0) this._rows = rows;
+      else this._rows = data.length;
+      if (typeof cols === 'number' && cols > 0) this._cols = cols;
+      else this._cols = data[0]?.length || 0;
+      if (addFn) this._addFn = addFn;
+      if (subtractFn) this._subtractFn = subtractFn;
+      if (multiplyFn) this._multiplyFn = multiplyFn;
+    } else {
+      this._rows = data.length;
+      this._cols = data[0]?.length ?? 0;
+    }
+
+    if (data.length > 0) {
+      this._data = data;
+    } else {
+      this._data = [];
+      for (let i = 0; i < this.rows; i++) {
+        this._data[i] = new Array(this.cols).fill(0);
+      }
+    }
+  }
+
+  protected _rows: number = 0;
+
+  get rows(): number {
+    return this._rows;
+  }
+
+  protected _cols: number = 0;
+
+  get cols(): number {
+    return this._cols;
+  }
+
+  protected _data: number[][];
+
+  get data(): number[][] {
+    return this._data;
+  }
+
+  get addFn() {
+    return this._addFn;
+  }
+
+  get subtractFn() {
+    return this._subtractFn;
+  }
+
+  get multiplyFn() {
+    return this._multiplyFn;
+  }
+
+  /**
+   * The `get` function returns the value at the specified row and column index if it is a valid index.
+   * @param {number} row - The `row` parameter represents the row index of the element you want to
+   * retrieve from the data array.
+   * @param {number} col - The parameter "col" represents the column number of the element you want to
+   * retrieve from the data array.
+   * @returns The `get` function returns a number if the provided row and column indices are valid.
+   * Otherwise, it returns `undefined`.
+   */
+  get(row: number, col: number): number | undefined {
+    if (this.isValidIndex(row, col)) {
+      return this.data[row][col];
+    }
+  }
+
+  /**
+   * The set function updates the value at a specified row and column in a two-dimensional array.
+   * @param {number} row - The "row" parameter represents the row index of the element in a
+   * two-dimensional array or matrix. It specifies the row where the value will be set.
+   * @param {number} col - The "col" parameter represents the column index of the element in a
+   * two-dimensional array.
+   * @param {number} value - The value parameter represents the number that you want to set at the
+   * specified row and column in the data array.
+   * @returns a boolean value. It returns true if the index (row, col) is valid and the value is
+   * successfully set in the data array. It returns false if the index is invalid and the value is not
+   * set.
+   */
+  set(row: number, col: number, value: number): boolean {
+    if (this.isValidIndex(row, col)) {
+      this.data[row][col] = value;
+      return true;
+    }
+    return false;
   }
 
-  /* The `toArray` method returns the matrix as a two-dimensional array. It converts the internal representation of the
-  matrix, which is an array of arrays, into a format that is more commonly used in JavaScript. */
-  toArray(): Array<Array<V>> {
-    return this._matrix;
+  /**
+   * The function checks if the dimensions of the given matrix match the dimensions of the current
+   * matrix.
+   * @param {Matrix} matrix - The parameter `matrix` is of type `Matrix`.
+   * @returns a boolean value.
+   */
+  isMatchForCalculate(matrix: Matrix): boolean {
+    return this.rows === matrix.rows && this.cols === matrix.cols;
+  }
+
+  /**
+   * The `add` function adds two matrices together, returning a new matrix with the result.
+   * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+   * @returns The `add` method returns a new `Matrix` object that represents the result of adding the
+   * current matrix with the provided `matrix` parameter.
+   */
+  add(matrix: Matrix): Matrix | undefined {
+    if (!this.isMatchForCalculate(matrix)) {
+      throw new Error('Matrix dimensions must match for addition.');
+    }
+
+    const resultData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      resultData[i] = [];
+      for (let j = 0; j < this.cols; j++) {
+        const a = this.get(i, j),
+          b = matrix.get(i, j);
+        if (a !== undefined && b !== undefined) {
+          const added = this._addFn(a, b);
+          if (added) {
+            resultData[i][j] = added;
+          }
+        }
+      }
+    }
+
+    return new Matrix(resultData, {
+      rows: this.rows,
+      cols: this.cols,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  /**
+   * The `subtract` function performs element-wise subtraction between two matrices and returns a new
+   * matrix with the result.
+   * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class. It
+   * represents the matrix that you want to subtract from the current matrix.
+   * @returns a new Matrix object with the result of the subtraction operation.
+   */
+  subtract(matrix: Matrix): Matrix | undefined {
+    if (!this.isMatchForCalculate(matrix)) {
+      throw new Error('Matrix dimensions must match for subtraction.');
+    }
+
+    const resultData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      resultData[i] = [];
+      for (let j = 0; j < this.cols; j++) {
+        const a = this.get(i, j),
+          b = matrix.get(i, j);
+        if (a !== undefined && b !== undefined) {
+          const subtracted = this._subtractFn(a, b);
+          if (subtracted) {
+            resultData[i][j] = subtracted;
+          }
+        }
+      }
+    }
+
+    return new Matrix(resultData, {
+      rows: this.rows,
+      cols: this.cols,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  /**
+   * The `multiply` function performs matrix multiplication between two matrices and returns the result
+   * as a new matrix.
+   * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+   * @returns a new Matrix object.
+   */
+  multiply(matrix: Matrix): Matrix | undefined {
+    if (this.cols !== matrix.rows) {
+      throw new Error('Matrix dimensions must be compatible for multiplication (A.cols = B.rows).');
+    }
+
+    const resultData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      resultData[i] = [];
+      for (let j = 0; j < matrix.cols; j++) {
+        let sum: number | undefined;
+        for (let k = 0; k < this.cols; k++) {
+          const a = this.get(i, k),
+            b = matrix.get(k, j);
+          if (a !== undefined && b !== undefined) {
+            const multiplied = this.multiplyFn(a, b);
+            if (multiplied !== undefined) {
+              sum = this.addFn(sum, multiplied);
+            }
+          }
+        }
+        if (sum !== undefined) resultData[i][j] = sum;
+      }
+    }
+
+    return new Matrix(resultData, {
+      rows: this.rows,
+      cols: matrix.cols,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  /**
+   * The transpose function takes a matrix and returns a new matrix that is the transpose of the
+   * original matrix.
+   * @returns The transpose() function returns a new Matrix object with the transposed data.
+   */
+  transpose(): Matrix {
+    if (this.data.some(row => row.length !== this.rows)) {
+      throw new Error('Matrix must be rectangular for transposition.');
+    }
+
+    const resultData: number[][] = [];
+
+    for (let j = 0; j < this.cols; j++) {
+      resultData[j] = [];
+      for (let i = 0; i < this.rows; i++) {
+        const trans = this.get(i, j);
+        if (trans !== undefined) resultData[j][i] = trans;
+      }
+    }
+
+    return new Matrix(resultData, {
+      rows: this.cols,
+      cols: this.rows,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  /**
+   * The `inverse` function calculates the inverse of a square matrix using Gaussian elimination.
+   * @returns a Matrix object, which represents the inverse of the original matrix.
+   */
+  inverse(): Matrix | undefined {
+    // Check if the matrix is square
+    if (this.rows !== this.cols) {
+      throw new Error('Matrix must be square for inversion.');
+    }
+
+    // Create an augmented matrix [this | I]
+    const augmentedMatrixData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      augmentedMatrixData[i] = this.data[i].slice(); // Copy the original matrix
+      for (let j = 0; j < this.cols; j++) {
+        augmentedMatrixData[i][this.cols + j] = i === j ? 1 : 0; // Append the identity matrix
+      }
+    }
+
+    const augmentedMatrix = new Matrix(augmentedMatrixData, {
+      rows: this.rows,
+      cols: this.cols * 2,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+
+    // Apply Gaussian elimination to transform the left half into the identity matrix
+    for (let i = 0; i < this.rows; i++) {
+      // Find pivot
+      let pivotRow = i;
+      while (pivotRow < this.rows && augmentedMatrix.get(pivotRow, i) === 0) {
+        pivotRow++;
+      }
+
+      if (pivotRow === this.rows) {
+        // Matrix is singular, and its inverse does not exist
+        throw new Error('Matrix is singular, and its inverse does not exist.');
+      }
+
+      // Swap rows to make the pivot the current row
+      augmentedMatrix._swapRows(i, pivotRow);
+
+      // Scale the pivot row to make the pivot element 1
+      const pivotElement = augmentedMatrix.get(i, i) ?? 1;
+
+      if (pivotElement === 0) {
+        // Handle division by zero
+        throw new Error('Matrix is singular, and its inverse does not exist (division by zero).');
+      }
+
+      augmentedMatrix._scaleRow(i, 1 / pivotElement);
+
+      // Eliminate other rows to make elements in the current column zero
+      for (let j = 0; j < this.rows; j++) {
+        if (j !== i) {
+          let factor = augmentedMatrix.get(j, i);
+          if (factor === undefined) factor = 0;
+
+          augmentedMatrix._addScaledRow(j, i, -factor);
+        }
+      }
+    }
+
+    // Extract the right half of the augmented matrix as the inverse
+    const inverseData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      inverseData[i] = augmentedMatrix.data[i].slice(this.cols);
+    }
+
+    return new Matrix(inverseData, {
+      rows: this.rows,
+      cols: this.cols,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  /**
+   * The dot function calculates the dot product of two matrices and returns a new matrix.
+   * @param {Matrix} matrix - The `matrix` parameter is an instance of the `Matrix` class.
+   * @returns a new Matrix object.
+   */
+  dot(matrix: Matrix): Matrix | undefined {
+    if (this.cols !== matrix.rows) {
+      throw new Error(
+        'Number of columns in the first matrix must be equal to the number of rows in the second matrix for dot product.'
+      );
+    }
+
+    const resultData: number[][] = [];
+    for (let i = 0; i < this.rows; i++) {
+      resultData[i] = [];
+      for (let j = 0; j < matrix.cols; j++) {
+        let sum: number | undefined;
+        for (let k = 0; k < this.cols; k++) {
+          const a = this.get(i, k),
+            b = matrix.get(k, j);
+          if (a !== undefined && b !== undefined) {
+            const multiplied = this.multiplyFn(a, b);
+            if (multiplied !== undefined) {
+              sum = this.addFn(sum, multiplied);
+            }
+          }
+        }
+        if (sum !== undefined) resultData[i][j] = sum;
+      }
+    }
+
+    return new Matrix(resultData, {
+      rows: this.rows,
+      cols: matrix.cols,
+      addFn: this.addFn,
+      subtractFn: this.subtractFn,
+      multiplyFn: this.multiplyFn
+    });
+  }
+
+  protected _addFn(a: number | undefined, b: number): number | undefined {
+    if (a === undefined) return b;
+    return a + b;
+  }
+
+  protected _subtractFn(a: number, b: number) {
+    return a - b;
+  }
+
+  protected _multiplyFn(a: number, b: number) {
+    return a * b;
+  }
+
+  /**
+   * The function checks if a given row and column index is valid within a specified range.
+   * @param {number} row - The `row` parameter represents the row index of a two-dimensional array or
+   * matrix. It is a number that indicates the specific row in the matrix.
+   * @param {number} col - The "col" parameter represents the column index in a two-dimensional array
+   * or grid. It is used to check if the given column index is valid within the bounds of the grid.
+   * @returns A boolean value is being returned.
+   */
+  protected isValidIndex(row: number, col: number): boolean {
+    return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
+  }
+
+  /**
+   * The function `_swapRows` swaps the positions of two rows in an array.
+   * @param {number} row1 - The `row1` parameter is the index of the first row that you want to swap.
+   * @param {number} row2 - The `row2` parameter is the index of the second row that you want to swap
+   * with the first row.
+   */
+  protected _swapRows(row1: number, row2: number): void {
+    const temp = this.data[row1];
+    this.data[row1] = this.data[row2];
+    this.data[row2] = temp;
+  }
+
+  /**
+   * The function scales a specific row in a matrix by a given scalar value.
+   * @param {number} row - The `row` parameter represents the index of the row in the matrix that you
+   * want to scale. It is a number that indicates the position of the row within the matrix.
+   * @param {number} scalar - The scalar parameter is a number that is used to multiply each element in
+   * a specific row of a matrix.
+   */
+  protected _scaleRow(row: number, scalar: number): void {
+    for (let j = 0; j < this.cols; j++) {
+      let multiplied = this.multiplyFn(this.data[row][j], scalar);
+      if (multiplied === undefined) multiplied = 0;
+      this.data[row][j] = multiplied;
+    }
+  }
+
+  /**
+   * The function `_addScaledRow` multiplies a row in a matrix by a scalar value and adds it to another
+   * row.
+   * @param {number} targetRow - The targetRow parameter represents the index of the row in which the
+   * scaled values will be added.
+   * @param {number} sourceRow - The sourceRow parameter represents the index of the row from which the
+   * values will be scaled and added to the targetRow.
+   * @param {number} scalar - The scalar parameter is a number that is used to scale the values in the
+   * source row before adding them to the target row.
+   */
+  protected _addScaledRow(targetRow: number, sourceRow: number, scalar: number): void {
+    for (let j = 0; j < this.cols; j++) {
+      let multiplied = this.multiplyFn(this.data[sourceRow][j], scalar);
+      if (multiplied === undefined) multiplied = 0;
+      const scaledValue = multiplied;
+      let added = this.addFn(this.data[targetRow][j], scaledValue);
+      if (added === undefined) added = 0;
+      this.data[targetRow][j] = added;
+    }
   }
 }

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

@@ -9,16 +9,17 @@ import type { PriorityQueueOptions } from '../../types';
 import { PriorityQueue } from './priority-queue';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-  constructor(elements?: Iterable<E>,
-              options: PriorityQueueOptions<E> = {
-                comparator: (a: E, b: E) => {
-                  if (!(typeof a === 'number' && typeof b === 'number')) {
-                    throw new Error('The a, b params of compare function must be number');
-                  } else {
-                    return a - b;
-                  }
-                }
-              }
+  constructor(
+    elements?: Iterable<E>,
+    options: PriorityQueueOptions<E> = {
+      comparator: (a: E, b: E) => {
+        if (!(typeof a === 'number' && typeof b === 'number')) {
+          throw new Error('The a, b params of compare function must be number');
+        } else {
+          return a - b;
+        }
+      }
+    }
   ) {
     super(elements, options);
   }

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

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback, IterableWithSizeOrLength } from "../../types";
-import { IterableElementBase } from "../base";
-import { calcMinUnitsRequired, rangeCheck } from "../../utils";
+import type { ElementCallback, IterableWithSizeOrLength } from '../../types';
+import { IterableElementBase } from '../base';
+import { calcMinUnitsRequired, rangeCheck } from '../../utils';
 
 /**
  * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
@@ -33,13 +33,15 @@ export class Deque<E> extends IterableElementBase<E> {
    * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
    * stored in each bucket. It determines the size of each bucket in the data structure.
    */
-  constructor(elements: IterableWithSizeOrLength<E> = [], bucketSize = (1 << 12)) {
+  constructor(elements: IterableWithSizeOrLength<E> = [], bucketSize = 1 << 12) {
     super();
     let _size: number;
     if ('length' in elements) {
-      if (elements.length instanceof Function) _size = elements.length(); else _size = elements.length;
+      if (elements.length instanceof Function) _size = elements.length();
+      else _size = elements.length;
     } else {
-      if (elements.size instanceof Function) _size = elements.size(); else _size = elements.size;
+      if (elements.size instanceof Function) _size = elements.size();
+      else _size = elements.size;
     }
 
     this._bucketSize = bucketSize;
@@ -49,7 +51,7 @@ export class Deque<E> extends IterableElementBase<E> {
     }
     const needBucketNum = calcMinUnitsRequired(_size, this._bucketSize);
     this._bucketFirst = this._bucketLast = (this._bucketCount >> 1) - (needBucketNum >> 1);
-    this._firstInBucket = this._lastInBucket = (this._bucketSize - _size % this._bucketSize) >> 1;
+    this._firstInBucket = this._lastInBucket = (this._bucketSize - (_size % this._bucketSize)) >> 1;
 
     for (const element of elements) {
       this.push(element);
@@ -108,10 +110,7 @@ export class Deque<E> extends IterableElementBase<E> {
         this._bucketLast = 0;
         this._lastInBucket = 0;
       }
-      if (
-        this._bucketLast === this._bucketFirst &&
-        this._lastInBucket === this._firstInBucket
-      ) this._reallocate();
+      if (this._bucketLast === this._bucketFirst && this._lastInBucket === this._firstInBucket) this._reallocate();
     }
     this._size += 1;
     this._buckets[this._bucketLast][this._lastInBucket] = element;
@@ -175,10 +174,7 @@ export class Deque<E> extends IterableElementBase<E> {
         this._bucketFirst = this._bucketCount - 1;
         this._firstInBucket = this._bucketSize - 1;
       }
-      if (
-        this._bucketFirst === this._bucketLast &&
-        this._firstInBucket === this._lastInBucket
-      ) this._reallocate();
+      if (this._bucketFirst === this._bucketLast && this._firstInBucket === this._lastInBucket) this._reallocate();
     }
     this._size += 1;
     this._buckets[this._bucketFirst][this._firstInBucket] = element;
@@ -260,7 +256,6 @@ export class Deque<E> extends IterableElementBase<E> {
     }
   }
 
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -278,14 +273,10 @@ export class Deque<E> extends IterableElementBase<E> {
    */
   getAt(pos: number): E {
     rangeCheck(pos, 0, this.size - 1);
-    const {
-      bucketIndex,
-      indexInBucket
-    } = this._getBucketAndPosition(pos);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     return this._buckets[bucketIndex][indexInBucket]!;
   }
 
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -303,10 +294,7 @@ export class Deque<E> extends IterableElementBase<E> {
    */
   setAt(pos: number, element: E): boolean {
     rangeCheck(pos, 0, this.size - 1);
-    const {
-      bucketIndex,
-      indexInBucket
-    } = this._getBucketAndPosition(pos);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     this._buckets[bucketIndex][indexInBucket] = element;
     return true;
   }
@@ -370,10 +358,7 @@ export class Deque<E> extends IterableElementBase<E> {
       this.clear();
       return 0;
     }
-    const {
-      bucketIndex,
-      indexInBucket
-    } = this._getBucketAndPosition(pos);
+    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     this._bucketLast = bucketIndex;
     this._lastInBucket = indexInBucket;
     this._size = pos + 1;
@@ -402,15 +387,9 @@ export class Deque<E> extends IterableElementBase<E> {
     else if (pos === this.size - 1) this.pop();
     else {
       const length = this.size - 1;
-      let {
-        bucketIndex: curBucket,
-        indexInBucket: curPointer
-      } = this._getBucketAndPosition(pos);
+      let { bucketIndex: curBucket, indexInBucket: curPointer } = this._getBucketAndPosition(pos);
       for (let i = pos; i < length; ++i) {
-        const {
-          bucketIndex: nextBucket,
-          indexInBucket: nextPointer
-        } = this._getBucketAndPosition(pos + 1);
+        const { bucketIndex: nextBucket, indexInBucket: nextPointer } = this._getBucketAndPosition(pos + 1);
         this._buckets[curBucket][curPointer] = this._buckets[nextBucket][nextPointer];
         curBucket = nextBucket;
         curPointer = nextPointer;
@@ -827,11 +806,11 @@ export class Deque<E> extends IterableElementBase<E> {
       bucketIndex -= this._bucketCount;
     }
 
-    indexInBucket = (overallIndex + 1) % this._bucketSize - 1;
+    indexInBucket = ((overallIndex + 1) % this._bucketSize) - 1;
     if (indexInBucket < 0) {
       indexInBucket = this._bucketSize - 1;
     }
 
     return { bucketIndex, indexInBucket };
   }
-}
+}

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

@@ -4,7 +4,7 @@
  * @class
  */
 import type { ElementCallback } from '../../types';
-import { IterableElementBase } from "../base";
+import { IterableElementBase } from '../base';
 import { SinglyLinkedList } from '../linked-list';
 
 /**

package/src/interfaces/binary-tree.ts

@@ -5,10 +5,15 @@ import {
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
-  BTNExemplar,
+  BTNExemplar
 } from '../types';
 
-export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
+export interface IBinaryTree<
+  K = number,
+  V = any,
+  N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>,
+  TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>
+> {
   createNode(key: K, value?: N['value']): N;
 
   createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;

package/src/types/common.ts

@@ -1,6 +1,6 @@
 export enum BSTVariant {
   MIN = 'MIN',
-  MAX = 'MAX',
+  MAX = 'MAX'
 }
 
 export enum CP {
@@ -46,15 +46,15 @@ export interface IterableWithLength<T> extends Iterable<T> {
   length: number | ((...args: any[]) => number);
 }
 
-export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
 
-export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
+export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
 
 export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
 
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>
+export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 
 export type BTNodePureKeyOrNode<K, N> = K | N;