doubly-linked-list-typed 1.52.0 → 1.52.2

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

@@ -367,7 +367,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R, Heap<E, R>
   /**
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     for (const element of this.elements) {
       yield element;
     }

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

@@ -803,7 +803,7 @@ export class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     let current = this.head;
 
     while (current) {

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

@@ -751,7 +751,7 @@ export class SinglyLinkedList<E = any, R = any> extends IterableElementBase<E, R
   /**
    * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     let current = this.head;
 
     while (current) {

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

@@ -32,8 +32,9 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     super(options);
 
     if (options) {
-      const { bucketSize } = options;
+      const { bucketSize, maxLen } = options;
       if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
+      if (typeof maxLen === 'number' && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
     }
 
     let _size: number;
@@ -73,6 +74,17 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     return this._bucketSize;
   }
 
+  protected _maxLen: number = -1;
+
+  /**
+   * The maxLen function returns the max length of the deque.
+   *
+   * @return The max length of the deque
+   */
+  get maxLen() {
+    return this._maxLen;
+  }
+
   protected _bucketFirst = 0;
 
   /**
@@ -193,6 +205,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     }
     this._size += 1;
     this._buckets[this._bucketLast][this._lastInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.shift();
     return true;
   }
 
@@ -257,6 +270,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
     }
     this._size += 1;
     this._buckets[this._bucketFirst][this._firstInBucket] = element;
+    if (this._maxLen > 0 && this._size > this._maxLen) this.pop();
     return true;
   }
 
@@ -330,7 +344,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
   /**
    * The below function is a generator that yields elements from a collection one by one.
    */
-  * begin(): Generator<E> {
+  *begin(): Generator<E> {
     let index = 0;
     while (index < this.size) {
       yield this.at(index);
@@ -342,7 +356,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
    * the last element.
    */
-  * reverseBegin(): Generator<E> {
+  *reverseBegin(): Generator<E> {
     let index = this.size - 1;
     while (index >= 0) {
       yield this.at(index);
@@ -834,7 +848,7 @@ export class Deque<E = any, R = any> extends IterableElementBase<E, R, Deque<E,
    * The above function is an implementation of the iterator protocol in TypeScript, allowing the
    * object to be iterated over using a for...of loop.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.size; ++i) {
       yield this.at(i);
     }

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

@@ -19,6 +19,12 @@ import { SinglyLinkedList } from '../linked-list';
 export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E, R>> {
   constructor(elements: Iterable<E> | Iterable<R> = [], options?: QueueOptions<E, R>) {
     super(options);
+
+    if (options) {
+      const { autoCompactRatio = 0.5 } = options;
+      this._autoCompactRatio = autoCompactRatio;
+    }
+
     if (elements) {
       for (const el of elements) {
         if (this.toElementFn) this.push(this.toElementFn(el as R));
@@ -89,6 +95,25 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
   }
 
+  _autoCompactRatio: number = 0.5;
+
+  /**
+   * This function returns the value of the autoCompactRatio property.
+   * @returns The `autoCompactRatio` property of the object, which is a number.
+   */
+  get autoCompactRatio(): number {
+    return this._autoCompactRatio;
+  }
+
+  /**
+   * The above function sets the autoCompactRatio property to a specified number in TypeScript.
+   * @param {number} v - The parameter `v` represents the value that will be assigned to the
+   * `_autoCompactRatio` property.
+   */
+  set autoCompactRatio(v: number) {
+    this._autoCompactRatio = v;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -100,7 +125,6 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    *
    * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
    * @public
-   * @static
    * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
    * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
    * array.
@@ -146,12 +170,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     const first = this.first;
     this._offset += 1;
 
-    if (this.offset * 2 < this.elements.length) return first;
-
-    // only delete dequeued elements when reaching half size
-    // to decrease latency of shifting elements.
-    this._elements = this.elements.slice(this.offset);
-    this._offset = 0;
+    if (this.offset / this.elements.length > this.autoCompactRatio) this.compact();
     return first;
   }
 
@@ -238,6 +257,17 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
     this._offset = 0;
   }
 
+  /**
+   * The `compact` function in TypeScript slices the elements array based on the offset and resets the
+   * offset to zero.
+   * @returns The `compact()` method is returning a boolean value of `true`.
+   */
+  compact(): boolean {
+    this._elements = this.elements.slice(this.offset);
+    this._offset = 0;
+    return true;
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -318,7 +348,7 @@ export class Queue<E = any, R = any> extends IterableElementBase<E, R, Queue<E,
    *
    * The function `_getIterator` returns an iterable iterator for the elements in the class.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     for (const item of this.elements.slice(this.offset)) {
       yield item;
     }

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

@@ -274,7 +274,7 @@ export class Stack<E = any, R = any> extends IterableElementBase<E, R, Stack<E,
    * Custom iterator for the Stack class.
    * @returns An iterator object.
    */
-  protected* _getIterator(): IterableIterator<E> {
+  protected *_getIterator(): IterableIterator<E> {
     for (let i = 0; i < this.elements.length; i++) {
       yield this.elements[i];
     }

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

@@ -560,7 +560,7 @@ export class Trie<R = any> extends IterableElementBase<string, R, Trie<R>> {
    * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
    * trie data structure and yields all the paths to the end nodes.
    */
-  protected* _getIterator(): IterableIterator<string> {
+  protected *_getIterator(): IterableIterator<string> {
     function* _dfs(node: TrieNode, path: string): IterableIterator<string> {
       if (node.isEnd) {
         yield path;

package/src/interfaces/binary-tree.ts

@@ -5,7 +5,7 @@ import type {
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
-  KeyOrNodeOrEntry
+  BTNKeyOrNodeOrEntry
 } from '../types';
 
 export interface IBinaryTree<
@@ -19,9 +19,9 @@ export interface IBinaryTree<
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): TREE;
 
-  add(keyOrNodeOrEntryOrRawElement: KeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
+  add(keyOrNodeOrEntryOrRawElement: BTNKeyOrNodeOrEntry<K, V, NODE>, value?: V, count?: number): boolean;
 
-  addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
+  addMany(nodes: Iterable<BTNKeyOrNodeOrEntry<K, V, NODE>>, values?: Iterable<V | undefined>): boolean[];
 
   delete<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<NODE>[];
 }

package/src/types/common.ts

@@ -1,11 +1,5 @@
 export type CP = 1 | -1 | 0;
 
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
 export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 
 export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
@@ -16,8 +10,6 @@ export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 
-export type BTNCallback<N, D = any> = (node: N) => D;
-
 export interface IterableWithSize<T> extends Iterable<T> {
   size: number | ((...args: any[]) => number);
 }
@@ -26,22 +18,8 @@ export interface IterableWithLength<T> extends Iterable<T> {
   length: number | ((...args: any[]) => number);
 }
 
-export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
-
-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 OptValue<V> = V | undefined;
 
-export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
-
-export type BTNodePureKeyOrNode<K, N> = K | N;
-
-export type BTNPureKeyOrNodeOrEntry<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
-
-export type BSTNKeyOrNode<K, N> = K | undefined | N;
-
-export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>;
 
 export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

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

@@ -1,5 +1,5 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
-import { BTNEntry, IterationType } from '../../common';
+import { IterationType, OptValue } from '../../common';
 
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
@@ -9,3 +9,23 @@ export type BinaryTreeOptions<K, V, R> = {
   iterationType?: IterationType;
   toEntryFn?: (rawElement: R) => BTNEntry<K, V>;
 }
+
+export type BinaryTreePrintOptions = { isShowUndefined?: boolean; isShowNull?: boolean; isShowRedBlackNIL?: boolean };
+
+export type OptBTNOrNull<NODE> = NODE | null | undefined;
+
+export type OptBTNKeyOrNull<K> = K | null | undefined;
+
+export type BTNEntry<K, V> = [OptBTNKeyOrNull<K>, OptValue<V>];
+
+export type BTNKeyOrNode<K, NODE> = OptBTNKeyOrNull<K> | NODE;
+
+export type BTNKeyOrNodeOrEntry<K, V, NODE> = BTNEntry<K, V> | BTNKeyOrNode<K, NODE>;
+
+export type BTNPureKeyOrNode<K, NODE> = K | NODE;
+
+export type BTNPureKeyOrNodeOrEntry<K, V, NODE> = [K, OptValue<V>] | BTNPureKeyOrNode<K, NODE>;
+
+export type BinaryTreeDeleteResult<NODE> = { deleted: OptBTNOrNull<NODE>; needBalanced: OptBTNOrNull<NODE> };
+
+export type BTNCallback<NODE, D = any> = (node: NODE) => D;

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

@@ -9,3 +9,10 @@ export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R,
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
   comparator?: Comparator<K>
 }
+
+export type OptBSTNKey<K> = K | undefined;
+
+export type OptBSTN<NODE> = NODE | undefined;
+
+export type BSTNKeyOrNode<K, NODE> = OptBSTNKey<K> | NODE;
+

package/src/types/data-structures/graph/abstract-graph.ts

@@ -2,12 +2,12 @@ export type VertexKey = string | number;
 
 export type DijkstraResult<V> =
   | {
-  distMap: Map<V, number>;
-  distPaths?: Map<V, V[]>;
-  preMap: Map<V, V | undefined>;
-  seen: Set<V>;
-  paths: V[][];
-  minDist: number;
-  minPath: V[];
-}
+      distMap: Map<V, number>;
+      distPaths?: Map<V, V[]>;
+      preMap: Map<V, V | undefined>;
+      seen: Set<V>;
+      paths: V[][];
+      minDist: number;
+      minPath: V[];
+    }
   | undefined;

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

@@ -1,3 +1,6 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type DequeOptions<E, R> = { bucketSize?: number } & IterableElementBaseOptions<E, R>;
+export type DequeOptions<E, R> = {
+  bucketSize?: number;
+  maxLen?: number;
+} & IterableElementBaseOptions<E, R>;

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

@@ -1,3 +1,5 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type QueueOptions<E, R> = IterableElementBaseOptions<E, R> & {
+  autoCompactRatio?: number;
+};

package/src/types/utils/utils.ts

@@ -13,9 +13,9 @@ export type Comparable =
   | bigint
   | boolean
   | ({ [key in string]: any } & {
-  valueOf(): Comparable;
-})
+      valueOf(): Comparable;
+    })
   | ({ [key in string]: any } & {
-  toString(): Comparable;
-})
+      toString(): Comparable;
+    })
   | (() => Comparable);