data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -19,39 +19,6 @@ export class SkipListNode<K, V> {
 }
 
 export class SkipList<K, V> {
-  get probability(): number {
-    return this._probability;
-  }
-
-  set probability(value: number) {
-    this._probability = value;
-  }
-  get maxLevel(): number {
-    return this._maxLevel;
-  }
-
-  set maxLevel(value: number) {
-    this._maxLevel = value;
-  }
-  get level(): number {
-    return this._level;
-  }
-
-  set level(value: number) {
-    this._level = value;
-  }
-  get head(): SkipListNode<K, V> {
-    return this._head;
-  }
-
-  set head(value: SkipListNode<K, V>) {
-    this._head = value;
-  }
-  private _head: SkipListNode<K, V>;
-  private _level: number;
-  private _maxLevel: number;
-  private _probability: number;
-
   /**
    * The constructor initializes a SkipList with a specified maximum level and probability.
    * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
@@ -66,16 +33,28 @@ export class SkipList<K, V> {
     this._probability = probability;
   }
 
-  /**
-   * The function "randomLevel" generates a random level based on a given probability and maximum level.
-   * @returns the level, which is a number.
-   */
-  private randomLevel(): number {
-    let level = 1;
-    while (Math.random() < this.probability && level < this.maxLevel) {
-      level++;
-    }
-    return level;
+  protected _head: SkipListNode<K, V>;
+
+  get head(): SkipListNode<K, V> {
+    return this._head;
+  }
+
+  protected _level: number;
+
+  get level(): number {
+    return this._level;
+  }
+
+  protected _maxLevel: number;
+
+  get maxLevel(): number {
+    return this._maxLevel;
+  }
+
+  protected _probability: number;
+
+  get probability(): number {
+    return this._probability;
   }
 
   /**
@@ -85,7 +64,7 @@ export class SkipList<K, V> {
    * List.
    */
   add(key: K, value: V): void {
-    const newNode = new SkipListNode(key, value, this.randomLevel());
+    const newNode = new SkipListNode(key, value, this._randomLevel());
     const update: SkipListNode<K, V>[] = new Array(this.maxLevel).fill(this.head);
     let current = this.head;
 
@@ -102,7 +81,7 @@ export class SkipList<K, V> {
     }
 
     if (newNode.forward[0] !== null) {
-      this.level = Math.max(this.level, newNode.forward.length);
+      this._level = Math.max(this.level, newNode.forward.length);
     }
   }
 
@@ -129,13 +108,17 @@ export class SkipList<K, V> {
     return undefined;
   }
 
+  has(key: K): boolean {
+    return this.get(key) !== undefined;
+  }
+
   /**
-   * The `remove` function removes a node with a specific key from a Skip List data structure.
+   * The `delete` function removes a node with a specific key from a Skip List data structure.
    * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-   * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+   * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
    * skip list, and `false` if the key was not found in the skip list.
    */
-  remove(key: K): boolean {
+  delete(key: K): boolean {
     const update: SkipListNode<K, V>[] = new Array(this.maxLevel).fill(this.head);
     let current = this.head;
 
@@ -156,11 +139,83 @@ export class SkipList<K, V> {
         update[i].forward[i] = current.forward[i];
       }
       while (this.level > 0 && this.head.forward[this.level - 1] === null) {
-        this.level--;
+        this._level--;
       }
       return true;
     }
 
     return false;
   }
+
+  /**
+   * Get the value of the first element (the smallest element) in the Skip List.
+   * @returns The value of the first element, or undefined if the Skip List is empty.
+   */
+  getFirst(): V | undefined {
+    const firstNode = this.head.forward[0];
+    return firstNode ? firstNode.value : undefined;
+  }
+
+  /**
+   * Get the value of the last element (the largest element) in the Skip List.
+   * @returns The value of the last element, or undefined if the Skip List is empty.
+   */
+  getLast(): V | undefined {
+    let current = this.head;
+    for (let i = this.level - 1; i >= 0; i--) {
+      while (current.forward[i]) {
+        current = current.forward[i];
+      }
+    }
+    return current.value;
+  }
+
+  /**
+   * Get the value of the first element in the Skip List that is greater than the given key.
+   * @param key - the given key.
+   * @returns The value of the first element greater than the given key, or undefined if there is no such element.
+   */
+  higher(key: K): V | undefined {
+    let current = this.head;
+    for (let i = this.level - 1; i >= 0; i--) {
+      while (current.forward[i] && current.forward[i].key <= key) {
+        current = current.forward[i];
+      }
+    }
+    const nextNode = current.forward[0];
+    return nextNode ? nextNode.value : undefined;
+  }
+
+  /**
+   * Get the value of the last element in the Skip List that is less than the given key.
+   * @param key - the given key.
+   * @returns The value of the last element less than the given key, or undefined if there is no such element.
+   */
+  lower(key: K): V | undefined {
+    let current = this.head;
+    let lastLess = null;
+
+    for (let i = this.level - 1; i >= 0; i--) {
+      while (current.forward[i] && current.forward[i].key < key) {
+        current = current.forward[i];
+      }
+      if (current.key < key) {
+        lastLess = current;
+      }
+    }
+
+    return lastLess ? lastLess.value : undefined;
+  }
+
+  /**
+   * The function "_randomLevel" generates a random level based on a given probability and maximum level.
+   * @returns the level, which is a number.
+   */
+  protected _randomLevel(): number {
+    let level = 1;
+    while (Math.random() < this.probability && level < this.maxLevel) {
+      level++;
+    }
+    return level;
+  }
 }

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

@@ -7,14 +7,14 @@
  */
 // todo need to be improved
 export class MatrixNTI2D<V = any> {
-  private readonly _matrix: Array<Array<V>>;
+  protected readonly _matrix: Array<Array<V>>;
 
   /**
    * 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:
    */
-  constructor(options: {row: number; col: number; initialVal?: V}) {
+  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));
   }

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

@@ -5,10 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import Vector2D from './vector2d';
+import {Vector2D} from './vector2d';
 
 export class Matrix2D {
-  private readonly _matrix: number[][];
+  protected readonly _matrix: number[][];
 
   /**
    * The constructor function initializes a Matrix2D object with either a default identity matrix, or a provided matrix
@@ -58,16 +58,6 @@ export class Matrix2D {
     return this._matrix;
   }
 
-  /**
-   * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
-   * _matrix array.
-   * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
-   * the first column of the matrix.
-   */
-  toVector(): Vector2D {
-    return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
-  }
-
   /**
    * The function takes two 2D matrices as input and returns their sum as a new 2D matrix.
    * @param {Matrix2D} matrix1 - Matrix2D - The first matrix to be added.
@@ -208,6 +198,14 @@ export class Matrix2D {
       [0, 0, vector.w]
     ]);
   }
-}
 
-export default Matrix2D;
+  /**
+   * The function "toVector" returns a new Vector2D object with the values from the first and second elements of the
+   * _matrix array.
+   * @returns A new instance of the Vector2D class is being returned. The values of the returned vector are taken from
+   * the first column of the matrix.
+   */
+  toVector(): Vector2D {
+    return new Vector2D(this._matrix[0][0], this._matrix[1][0]);
+  }
+}

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

@@ -27,10 +27,10 @@ export class Character {
 
 export class Navigator<T = number> {
   onMove: (cur: [number, number]) => void;
-  private readonly _matrix: T[][];
-  private readonly _cur: [number, number];
-  private _character: Character;
-  private readonly _VISITED: T;
+  protected readonly _matrix: T[][];
+  protected readonly _cur: [number, number];
+  protected _character: Character;
+  protected readonly _VISITED: T;
 
   /**
    * The constructor initializes the Navigator object with the given parameters and sets the current position as visited

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

@@ -10,7 +10,8 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {}
+  ) {
+  }
 
   /**
    * The function checks if the x and y values of a point are both zero.
@@ -312,5 +313,3 @@ export class Vector2D {
     this.y = 0;
   }
 }
-
-export default Vector2D;

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

@@ -1,56 +1,25 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
-import type {PriorityQueueOptions, SpecifyOptional} from '../../types';
+import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
-  constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
-  constructor(options: PriorityQueueOptions<E>);
-
-  /**
-   * The constructor initializes a priority queue with an optional comparator function.
-   * @param [options] - The `options` parameter is an optional object that can contain various properties to configure
-   * the priority queue.
-   */
-  constructor(options?: SpecifyOptional<PriorityQueueOptions<E>, 'comparator'>) {
-    super({
-      ...options,
-      comparator: options?.comparator
-        ? options.comparator
-        : (a: E, b: E) => {
-            const aKey = a as unknown as number,
-              bKey = b as unknown as number;
-            return bKey - aKey;
-          }
-    });
-  }
-
-  static override heapify<E extends number>(options?: Omit<PriorityQueueOptions<E>, 'comparator'>): MaxPriorityQueue<E>;
-  static override heapify<E>(options: PriorityQueueOptions<E>): MaxPriorityQueue<E>;
-
-  /**
-   * The function `heapify` creates a max priority queue from the given options and returns it.
-   * @param options - The `options` parameter is an object that contains configuration options for creating a priority
-   * queue. It can have the following properties:
-   * @returns a MaxPriorityQueue object.
-   */
-  static override heapify<E>(options: PriorityQueueOptions<E>): MaxPriorityQueue<E> {
-    const maxPQ = new MaxPriorityQueue<E>({
-      ...options,
-      comparator: options?.comparator
-        ? options.comparator
-        : (a: E, b: E) => {
-            const aKey = a as unknown as number,
-              bKey = b as unknown as number;
-            return bKey - aKey;
-          }
-    });
-    maxPQ._fix();
-    return maxPQ;
+  constructor(
+    options: { comparator: Comparator<E>; nodes?: 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 b - a;
+        }
+      }
+    }
+  ) {
+    super(options);
   }
 }

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

@@ -1,57 +1,25 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import {PriorityQueue} from './priority-queue';
-import type {PriorityQueueOptions, SpecifyOptional} from '../../types';
+import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-  constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
-  constructor(options: PriorityQueueOptions<E>);
-
-  /**
-   * The constructor initializes a priority queue with an optional comparator function.
-   * @param [options] - The `options` parameter is an optional object that can contain various configuration options for
-   * the `PriorityQueue` constructor.
-   */
-  constructor(options?: SpecifyOptional<PriorityQueueOptions<E>, 'comparator'>) {
-    super({
-      ...options,
-      comparator: options?.comparator
-        ? options.comparator
-        : (a: E, b: E) => {
-            const aKey = a as unknown as number,
-              bKey = b as unknown as number;
-            return aKey - bKey;
-          }
-    });
-  }
-
-  static override heapify<E extends number>(options?: Omit<PriorityQueueOptions<E>, 'comparator'>): MinPriorityQueue<E>;
-  static override heapify<E>(options: PriorityQueueOptions<E>): MinPriorityQueue<E>;
-
-  /**
-   * The function `heapify` creates a new MinPriorityQueue instance and sets the comparator function based on the options
-   * provided, and then fixes the heap structure of the queue.
-   * @param options - The `options` parameter is an object that contains configuration options for creating a priority
-   * queue. It can have the following properties:
-   * @returns a MinPriorityQueue object.
-   */
-  static override heapify<E>(options: PriorityQueueOptions<E>): MinPriorityQueue<E> {
-    const minPQ = new MinPriorityQueue<E>({
-      ...options,
-      comparator: options?.comparator
-        ? options.comparator
-        : (a: E, b: E) => {
-            const aKey = a as unknown as number,
-              bKey = b as unknown as number;
-            return aKey - bKey;
-          }
-    });
-    minPQ._fix();
-    return minPQ;
+  constructor(
+    options: { comparator: Comparator<E>; nodes?: 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(options);
   }
 }