min-heap-typed 1.50.1 → 1.50.2

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

@@ -20,6 +20,14 @@ export class SkipListNode<K, V> {
 }
 
 export class SkipList<K, V> {
+  /**
+   * The constructor function initializes a SkipLinkedList object with optional options and elements.
+   * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+   * is used to initialize the SkipLinkedList with the given key-value pairs. If no elements are
+   * provided, the SkipLinkedList will be empty.
+   * @param {SkipLinkedListOptions} [options] - The `options` parameter is an optional object that can
+   * contain two properties:
+   */
   constructor(elements: Iterable<[K, V]> = [], options?: SkipLinkedListOptions) {
     if (options) {
       const { maxLevel, probability } = options;
@@ -34,36 +42,52 @@ export class SkipList<K, V> {
 
   protected _head: SkipListNode<K, V> = new SkipListNode<K, V>(undefined as any, undefined as any, this.maxLevel);
 
+  /**
+   * The function returns the head node of a SkipList.
+   * @returns The method is returning a SkipListNode object with generic key type K and value type V.
+   */
   get head(): SkipListNode<K, V> {
     return this._head;
   }
 
   protected _level: number = 0;
 
+  /**
+   * The function returns the value of the private variable _level.
+   * @returns The level property of the object.
+   */
   get level(): number {
     return this._level;
   }
 
   protected _maxLevel: number = 16;
 
+  /**
+   * The function returns the maximum level.
+   * @returns The value of the variable `_maxLevel` is being returned.
+   */
   get maxLevel(): number {
     return this._maxLevel;
   }
 
   protected _probability: number = 0.5;
 
+  /**
+   * The function returns the probability value.
+   * @returns The probability value stored in the private variable `_probability` is being returned.
+   */
   get probability(): number {
     return this._probability;
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    *
    * 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.
@@ -74,13 +98,13 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * 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.
@@ -96,13 +120,13 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * The add function adds a new node with a given key and value to a Skip List data structure.
    * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
@@ -132,13 +156,13 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * The function `get` retrieves the value associated with a given key from a skip list data structure.
    * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
@@ -163,27 +187,28 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * The function checks if a key exists in a data structure.
+   * @param {K} key - The parameter "key" is of type K, which represents the type of the key being
+   * checked.
+   * @returns a boolean value.
    */
-
   has(key: K): boolean {
     return this.get(key) !== undefined;
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * 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.
@@ -220,13 +245,13 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * Get the value of the first element in the Skip List that is greater than the given key.
    * @param key - the given key.
@@ -244,13 +269,13 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
-   * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
    *
    * Get the value of the last element in the Skip List that is less than the given key.
    * @param key - the given key.
@@ -273,13 +298,14 @@ export class SkipList<K, V> {
   }
 
   /**
-   * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
-   * Space Complexity: O(1) - constant space.
+   * Time Complexity: O(maxLevel)
+   * Space Complexity: O(1)
+   * where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
    */
 
   /**
-   * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
-   * Space Complexity: O(1) - constant space.
+   * Time Complexity: O(maxLevel)
+   * Space Complexity: O(1)
    *
    * The function "_randomLevel" generates a random level based on a given probability and maximum level.
    * @returns the level, which is a number.

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

@@ -42,30 +42,54 @@ export class Matrix {
 
   protected _rows: number = 0;
 
+  /**
+   * The function returns the number of rows.
+   * @returns The number of rows.
+   */
   get rows(): number {
     return this._rows;
   }
 
   protected _cols: number = 0;
 
+  /**
+   * The function returns the value of the private variable _cols.
+   * @returns The number of columns.
+   */
   get cols(): number {
     return this._cols;
   }
 
   protected _data: number[][];
 
+  /**
+   * The function returns a two-dimensional array of numbers.
+   * @returns The data property, which is a two-dimensional array of numbers.
+   */
   get data(): number[][] {
     return this._data;
   }
 
+  /**
+   * The above function returns the value of the _addFn property.
+   * @returns The value of the property `_addFn` is being returned.
+   */
   get addFn() {
     return this._addFn;
   }
 
+  /**
+   * The function returns the value of the _subtractFn property.
+   * @returns The `_subtractFn` property is being returned.
+   */
   get subtractFn() {
     return this._subtractFn;
   }
 
+  /**
+   * The function returns the value of the _multiplyFn property.
+   * @returns The `_multiplyFn` property is being returned.
+   */
   get multiplyFn() {
     return this._multiplyFn;
   }
@@ -373,6 +397,34 @@ export class Matrix {
     });
   }
 
+  /**
+   * 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.
+   */
+  isValidIndex(row: number, col: number): boolean {
+    return row >= 0 && row < this.rows && col >= 0 && col < this.cols;
+  }
+
+  /**
+   * The `clone` function returns a new instance of the Matrix class with the same data and properties
+   * as the original instance.
+   * @returns The `clone()` method is returning a new instance of the `Matrix` class with the same data
+   * and properties as the current instance.
+   */
+  clone(): Matrix {
+    return new Matrix(this.data, {
+      rows: this.rows,
+      cols: this.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;
@@ -386,18 +438,6 @@ export class Matrix {
     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.

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

@@ -24,6 +24,17 @@ export class Deque<E> extends IterableElementBase<E> {
   protected _bucketCount = 0;
   protected readonly _bucketSize: number = 1 << 12;
 
+  /**
+   * The constructor initializes a Deque object with an optional iterable of elements and options.
+   * @param elements - An iterable object (such as an array or a Set) that contains the initial
+   * elements to be added to the deque. It can also be an object with a `length` or `size` property
+   * that represents the number of elements in the iterable object. If no elements are provided, an
+   * empty deque
+   * @param {DequeOptions} [options] - The `options` parameter is an optional object that can contain
+   * configuration options for the deque. In this code, it is used to set the `bucketSize` option,
+   * which determines the size of each bucket in the deque. If the `bucketSize` option is not provided
+   * or is not a number
+   */
   constructor(elements: IterableWithSizeOrLength<E> = [], options?: DequeOptions) {
     super();
 
@@ -54,14 +65,32 @@ export class Deque<E> extends IterableElementBase<E> {
     }
   }
 
+  /**
+   * The bucketSize function returns the size of the bucket.
+   *
+   * @return The size of the bucket
+   */
+  get bucketSize() {
+    return this._bucketSize;
+  }
+
   protected _buckets: E[][] = [];
 
+  /**
+   * The buckets function returns the buckets property of the object.
+   *
+   * @return The buckets property
+   */
   get buckets() {
     return this._buckets;
   }
 
   protected _size = 0;
 
+  /**
+   * The size function returns the number of items in the stack.
+   * @return The number of values in the set
+   */
   get size() {
     return this._size;
   }
@@ -76,6 +105,10 @@ export class Deque<E> extends IterableElementBase<E> {
     return this._buckets[this._bucketFirst][this._firstInBucket];
   }
 
+  /**
+   * The last function returns the last element in the queue.
+   * @return The last element in the array
+   */
   get last(): E | undefined {
     if (this.size === 0) return;
     return this._buckets[this._bucketLast][this._lastInBucket];
@@ -235,7 +268,7 @@ export class Deque<E> extends IterableElementBase<E> {
   * begin(): Generator<E> {
     let index = 0;
     while (index < this.size) {
-      yield this.getAt(index);
+      yield this.at(index);
       index++;
     }
   }
@@ -247,7 +280,7 @@ export class Deque<E> extends IterableElementBase<E> {
   * reverseBegin(): Generator<E> {
     let index = this.size - 1;
     while (index >= 0) {
-      yield this.getAt(index);
+      yield this.at(index);
       index--;
     }
   }
@@ -261,13 +294,13 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
-   * The `getAt` function retrieves an element at a specified position in an array-like data structure.
+   * The `at` function retrieves an element at a specified position in an array-like data structure.
    * @param {number} pos - The `pos` parameter represents the position of the element that you want to
    * retrieve from the data structure. It is of type `number` and should be a valid index within the
    * range of the data structure.
    * @returns The element at the specified position in the data structure is being returned.
    */
-  getAt(pos: number): E {
+  at(pos: number): E {
     rangeCheck(pos, 0, this.size - 1);
     const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
     return this._buckets[bucketIndex][indexInBucket]!;
@@ -325,9 +358,9 @@ export class Deque<E> extends IterableElementBase<E> {
     } else {
       const arr: E[] = [];
       for (let i = pos; i < this.size; ++i) {
-        arr.push(this.getAt(i));
+        arr.push(this.at(i));
       }
-      this.cut(pos - 1);
+      this.cut(pos - 1, true);
       for (let i = 0; i < num; ++i) this.push(element);
       for (let i = 0; i < arr.length; ++i) this.push(arr[i]);
     }
@@ -347,18 +380,51 @@ export class Deque<E> extends IterableElementBase<E> {
    * updated size.
    * @param {number} pos - The `pos` parameter represents the position at which the string should be
    * cut. It is a number that indicates the index of the character where the cut should be made.
+   * @param {boolean} isCutSelf - If true, the original deque will not be cut, and return a new deque
    * @returns The method is returning the updated size of the data structure.
    */
-  cut(pos: number): number {
-    if (pos < 0) {
-      this.clear();
-      return 0;
+  cut(pos: number, isCutSelf = false): Deque<E> {
+    if (isCutSelf) {
+      if (pos < 0) {
+        this.clear();
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketLast = bucketIndex;
+      this._lastInBucket = indexInBucket;
+      this._size = pos + 1;
+      return this;
+    } else {
+      const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
+
+      for (let i = 0; i <= pos; i++) {
+        newDeque.push(this.at(i));
+      }
+
+      return newDeque;
+    }
+  }
+
+  cutRest(pos: number, isCutSelf = false): Deque<E> {
+    if (isCutSelf) {
+      if (pos < 0) {
+        this.clear();
+        return this;
+      }
+      const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
+      this._bucketFirst = bucketIndex;
+      this._firstInBucket = indexInBucket;
+      this._size = this._size - pos;
+      return this;
+    } else {
+      const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
+
+      for (let i = pos; i < this.size; i++) {
+        newDeque.push(this.at(i));
+      }
+
+      return newDeque;
     }
-    const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
-    this._bucketLast = bucketIndex;
-    this._lastInBucket = indexInBucket;
-    this._size = pos + 1;
-    return this.size;
   }
 
   /**
@@ -416,14 +482,14 @@ export class Deque<E> extends IterableElementBase<E> {
     let i = 0;
     let index = 0;
     while (i < size) {
-      const oldElement = this.getAt(i);
+      const oldElement = this.at(i);
       if (oldElement !== element) {
         this.setAt(index, oldElement!);
         index += 1;
       }
       i += 1;
     }
-    this.cut(index - 1);
+    this.cut(index - 1, true);
     return true;
   }
 
@@ -471,15 +537,15 @@ export class Deque<E> extends IterableElementBase<E> {
       return this;
     }
     let index = 1;
-    let prev = this.getAt(0);
+    let prev = this.at(0);
     for (let i = 1; i < this.size; ++i) {
-      const cur = this.getAt(i);
+      const cur = this.at(i);
       if (cur !== prev) {
         prev = cur;
         this.setAt(index++, cur);
       }
     }
-    this.cut(index - 1);
+    this.cut(index - 1, true);
     return this;
   }
 
@@ -501,7 +567,7 @@ export class Deque<E> extends IterableElementBase<E> {
   sort(comparator?: (x: E, y: E) => number): this {
     const arr: E[] = [];
     for (let i = 0; i < this.size; ++i) {
-      arr.push(this.getAt(i));
+      arr.push(this.at(i));
     }
     arr.sort(comparator);
     for (let i = 0; i < this.size; ++i) {
@@ -545,32 +611,6 @@ export class Deque<E> extends IterableElementBase<E> {
     this._buckets = newBuckets;
   }
 
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `find` function iterates over the elements in a deque and returns the first element for which
-   * the callback function returns true, or undefined if no such element is found.
-   * @param callback - A function that takes three parameters: element, index, and deque. It should
-   * return a boolean value indicating whether the element satisfies a certain condition.
-   * @returns The method `find` returns the first element in the deque that satisfies the condition
-   * specified by the callback function. If no element satisfies the condition, it returns `undefined`.
-   */
-  find(callback: (element: E, index: number, deque: Deque<E>) => boolean): E | undefined {
-    for (let i = 0; i < this.size; ++i) {
-      const element = this.getAt(i);
-      if (callback(element, i, this)) {
-        return element;
-      }
-    }
-    return;
-  }
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)
@@ -589,7 +629,7 @@ export class Deque<E> extends IterableElementBase<E> {
    */
   indexOf(element: E): number {
     for (let i = 0; i < this.size; ++i) {
-      if (this.getAt(i) === element) {
+      if (this.at(i) === element) {
         return i;
       }
     }
@@ -616,6 +656,25 @@ export class Deque<E> extends IterableElementBase<E> {
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone()` function returns a new instance of the `Deque` class with the same elements and
+   * bucket size as the original instance.
+   * @returns The `clone()` method is returning a new instance of the `Deque` class with the same
+   * elements as the original deque (`this`) and the same bucket size.
+   */
+  clone(): Deque<E> {
+    return new Deque<E>([...this], { bucketSize: this.bucketSize });
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -737,7 +796,7 @@ export class Deque<E> extends IterableElementBase<E> {
    */
   protected* _getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.size; ++i) {
-      yield this.getAt(i);
+      yield this.at(i);
     }
   }