stack-typed 1.47.6 → 1.47.8

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

@@ -7,16 +7,16 @@
  */
 export class SinglyLinkedListNode<E = any> {
   value: E;
-  next: SinglyLinkedListNode<E> | null;
+  next: SinglyLinkedListNode<E> | undefined;
 
   /**
-   * The constructor function initializes an instance of a class with a given value and sets the next property to null.
+   * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
    * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
    * will be stored in the node of a linked list.
    */
   constructor(value: E) {
     this.value = value;
-    this.next = null;
+    this.next = undefined;
   }
 }
 
@@ -25,8 +25,8 @@ export class SinglyLinkedList<E = any> {
    * The constructor initializes the linked list with an empty head, tail, and length.
    */
   constructor(elements?: Iterable<E>) {
-    this._head = null;
-    this._tail = null;
+    this._head = undefined;
+    this._tail = undefined;
     this._length = 0;
     if (elements) {
       for (const el of elements)
@@ -34,15 +34,15 @@ export class SinglyLinkedList<E = any> {
     }
   }
 
-  protected _head: SinglyLinkedListNode<E> | null;
+  protected _head: SinglyLinkedListNode<E> | undefined;
 
-  get head(): SinglyLinkedListNode<E> | null {
+  get head(): SinglyLinkedListNode<E> | undefined {
     return this._head;
   }
 
-  protected _tail: SinglyLinkedListNode<E> | null;
+  protected _tail: SinglyLinkedListNode<E> | undefined;
 
-  get tail(): SinglyLinkedListNode<E> | null {
+  get tail(): SinglyLinkedListNode<E> | undefined {
     return this._tail;
   }
 
@@ -128,14 +128,14 @@ export class SinglyLinkedList<E = any> {
    * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
    * pointers accordingly.
    * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-   * the linked list is empty, it returns `null`.
+   * the linked list is empty, it returns `undefined`.
    */
   pop(): E | undefined {
     if (!this.head) return undefined;
     if (this.head === this.tail) {
       const value = this.head.value;
-      this._head = null;
-      this._tail = null;
+      this._head = undefined;
+      this._tail = undefined;
       this._length--;
       return value;
     }
@@ -145,7 +145,7 @@ export class SinglyLinkedList<E = any> {
       current = current.next!;
     }
     const value = this.tail!.value;
-    current.next = null;
+    current.next = undefined;
     this._tail = current;
     this._length--;
     return value;
@@ -163,7 +163,7 @@ export class SinglyLinkedList<E = any> {
    * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
    * pointers accordingly.
    * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
-   * the linked list is empty, it returns `null`.
+   * the linked list is empty, it returns `undefined`.
    */
   popLast(): E | undefined {
     return this.pop();
@@ -256,11 +256,11 @@ export class SinglyLinkedList<E = any> {
    * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
    * Space Complexity: O(1) - Constant space.
    *
-   * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
+   * The function `getAt` returns the value at a specified index in a linked list, or undefined if the index is out of range.
    * @param {number} index - The index parameter is a number that represents the position of the element we want to
    * retrieve from the list.
-   * @returns The method `getAt(index: number): E | null` returns the value at the specified index in the linked list, or
-   * `null` if the index is out of bounds.
+   * @returns The method `getAt(index: number): E | undefined` returns the value at the specified index in the linked list, or
+   * `undefined` if the index is out of bounds.
    */
   getAt(index: number): E | undefined {
     if (index < 0 || index >= this.length) return undefined;
@@ -284,9 +284,9 @@ export class SinglyLinkedList<E = any> {
    * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
    * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
    * @returns The method `getNodeAt(index: number)` returns a `SinglyLinkedListNode<E>` object if the node at the
-   * specified index exists, or `null` if the index is out of bounds.
+   * specified index exists, or `undefined` if the index is out of bounds.
    */
-  getNodeAt(index: number): SinglyLinkedListNode<E> | null {
+  getNodeAt(index: number): SinglyLinkedListNode<E> | undefined {
     let current = this.head;
     for (let i = 0; i < index; i++) {
       current = current!.next;
@@ -306,7 +306,7 @@ export class SinglyLinkedList<E = any> {
    * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
    * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
    * data structure. It is of type number.
-   * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+   * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
    * bounds.
    */
   deleteAt(index: number): E | undefined {
@@ -336,7 +336,7 @@ export class SinglyLinkedList<E = any> {
    * @returns The `delete` method returns a boolean value. It returns `true` if the value or node is found and
    * successfully deleted from the linked list, and `false` if the value or node is not found in the linked list.
    */
-  delete(valueOrNode: E | SinglyLinkedListNode<E> | null | undefined): boolean {
+  delete(valueOrNode: E | SinglyLinkedListNode<E> | undefined | undefined): boolean {
     if (!valueOrNode) return false;
     let value: E;
     if (valueOrNode instanceof SinglyLinkedListNode) {
@@ -345,14 +345,14 @@ export class SinglyLinkedList<E = any> {
       value = valueOrNode;
     }
     let current = this.head,
-      prev = null;
+      prev = undefined;
 
     while (current) {
       if (current.value === value) {
-        if (prev === null) {
+        if (prev === undefined) {
           this._head = current.next;
           if (current === this.tail) {
-            this._tail = null;
+            this._tail = undefined;
           }
         } else {
           prev.next = current.next;
@@ -416,11 +416,11 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
-   * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+   * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
    */
   clear(): void {
-    this._head = null;
-    this._tail = null;
+    this._head = undefined;
+    this._tail = undefined;
     this._length = 0;
   }
 
@@ -461,9 +461,9 @@ export class SinglyLinkedList<E = any> {
   reverse(): void {
     if (!this.head || this.head === this.tail) return;
 
-    let prev: SinglyLinkedListNode<E> | null = null;
-    let current: SinglyLinkedListNode<E> | null = this.head;
-    let next: SinglyLinkedListNode<E> | null = null;
+    let prev: SinglyLinkedListNode<E> | undefined = undefined;
+    let current: SinglyLinkedListNode<E> | undefined = this.head;
+    let next: SinglyLinkedListNode<E> | undefined = undefined;
 
     while (current) {
       next = current.next;
@@ -488,9 +488,9 @@ export class SinglyLinkedList<E = any> {
    * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
    * function is used to determine whether a particular value in the linked list satisfies a certain condition.
    * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-   * the callback function. If no element satisfies the condition, it returns `null`.
+   * the callback function. If no element satisfies the condition, it returns `undefined`.
    */
-  find(callback: (value: E) => boolean): E | null {
+  find(callback: (value: E) => boolean): E | undefined {
     let current = this.head;
     while (current) {
       if (callback(current.value)) {
@@ -498,7 +498,7 @@ export class SinglyLinkedList<E = any> {
       }
       current = current.next;
     }
-    return null;
+    return undefined;
   }
 
   /**
@@ -540,12 +540,12 @@ export class SinglyLinkedList<E = any> {
    * Space Complexity: O(1) - Constant space.
    *
    * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
-   * null.
+   * undefined.
    * @param {E} value - The value parameter is the value that we want to search for in the linked list.
    * @returns a `SinglyLinkedListNode<E>` if a node with the specified value is found in the linked list. If no node with
-   * the specified value is found, the function returns `null`.
+   * the specified value is found, the function returns `undefined`.
    */
-  getNode(value: E): SinglyLinkedListNode<E> | null {
+  getNode(value: E): SinglyLinkedListNode<E> | undefined {
     let current = this.head;
 
     while (current) {
@@ -555,7 +555,7 @@ export class SinglyLinkedList<E = any> {
       current = current.next;
     }
 
-    return null;
+    return undefined;
   }
 
   /**
@@ -620,7 +620,7 @@ export class SinglyLinkedList<E = any> {
    * existing value or node, and false if the existing value or node was not found in the linked list.
    */
   insertAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean {
-    let existingNode: E | SinglyLinkedListNode<E> | null;
+    let existingNode: E | SinglyLinkedListNode<E> | undefined;
 
     if (existingValueOrNode instanceof SinglyLinkedListNode) {
       existingNode = existingValueOrNode;

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

@@ -27,7 +27,7 @@ export class SkipList<K, V> {
    * level in the skip list. It is used to determine the height of each node in the skip list.
    */
   constructor(maxLevel = 16, probability = 0.5) {
-    this._head = new SkipListNode<K, V>(null as any, null as any, maxLevel);
+    this._head = new SkipListNode<K, V>(undefined as any, undefined as any, maxLevel);
     this._level = 0;
     this._maxLevel = maxLevel;
     this._probability = probability;
@@ -88,7 +88,7 @@ export class SkipList<K, V> {
       update[i].forward[i] = newNode;
     }
 
-    if (newNode.forward[0] !== null) {
+    if (!newNode.forward[0]) {
       this._level = Math.max(this.level, newNode.forward.length);
     }
   }
@@ -172,7 +172,7 @@ export class SkipList<K, V> {
         }
         update[i].forward[i] = current.forward[i];
       }
-      while (this.level > 0 && this.head.forward[this.level - 1] === null) {
+      while (this.level > 0 && !this.head.forward[this.level - 1]) {
         this._level--;
       }
       return true;
@@ -259,7 +259,7 @@ export class SkipList<K, V> {
    */
   lower(key: K): V | undefined {
     let current = this.head;
-    let lastLess = null;
+    let lastLess = undefined;
 
     for (let i = this.level - 1; i >= 0; i--) {
       while (current.forward[i] && current.forward[i].key < key) {

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

@@ -15,8 +15,8 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   }
 
   /**
-   * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-   * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+   * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
    */
   dequeue(): E | undefined {
     return this.shift();
@@ -112,7 +112,7 @@ export class Queue<E = any> {
    *
    * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
    * necessary to optimize performance.
-   * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+   * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
    */
   shift(): E | undefined {
     if (this.size === 0) return undefined;
@@ -138,9 +138,9 @@ export class Queue<E = any> {
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+   * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
    * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
-   * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+   * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   getFirst(): E | undefined {
     return this.size > 0 ? this.nodes[this.offset] : undefined;
@@ -155,9 +155,9 @@ export class Queue<E = any> {
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+   * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
    * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
-   * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+   * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   peek(): E | undefined {
     return this.getFirst();
@@ -172,9 +172,9 @@ export class Queue<E = any> {
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+   * The `getLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
    * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-   * array is empty, it returns `null`.
+   * array is empty, it returns `undefined`.
    */
   getLast(): E | undefined {
     return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
@@ -189,9 +189,9 @@ export class Queue<E = any> {
    * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
    * Space Complexity: O(1) - no additional space is used.
    *
-   * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+   * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
    * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
-   * array is empty, it returns `null`.
+   * array is empty, it returns `undefined`.
    */
   peekLast(): E | undefined {
     return this.getLast();
@@ -222,8 +222,8 @@ export class Queue<E = any> {
    * Time Complexity: O(n) - same as shift().
    * Space Complexity: O(1) - same as shift().
    *
-   * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
-   * @returns The method is returning a value of type E or null.
+   * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
+   * @returns The method is returning a value of type E or undefined.
    */
   dequeue(): E | undefined {
     return this.shift();

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

@@ -68,11 +68,11 @@ export class Stack<E = any> {
    * Time Complexity: O(1), as it only involves accessing the last element of the array.
    * Space Complexity: O(1), as it does not use any additional space.
    *
-   * The `peek` function returns the last element of an array, or null if the array is empty.
-   * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
+   * The `peek` function returns the last element of an array, or undefined if the array is empty.
+   * @returns The `peek()` function returns the last element of the `_elements` array, or `undefined` if the array is empty.
    */
-  peek(): E | null {
-    if (this.isEmpty()) return null;
+  peek(): E | undefined {
+    if (this.isEmpty()) return undefined;
 
     return this.elements[this.elements.length - 1];
   }
@@ -104,14 +104,14 @@ export class Stack<E = any> {
    * Time Complexity: O(1), as it only involves accessing the last element of the array.
    * Space Complexity: O(1), as it does not use any additional space.
    *
-   * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
+   * The `pop` function removes and returns the last element from an array, or returns undefined if the array is empty.
    * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-   * array is empty, it returns `null`.
+   * array is empty, it returns `undefined`.
    */
-  pop(): E | null {
-    if (this.isEmpty()) return null;
+  pop(): E | undefined {
+    if (this.isEmpty()) return undefined;
 
-    return this.elements.pop() || null;
+    return this.elements.pop() || undefined;
   }
 
   /**

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

@@ -29,13 +29,20 @@ export class Trie {
   constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
     this._caseSensitive = caseSensitive;
+    this._size = 0;
     if (words) {
-      for (const i of words) {
-        this.add(i);
+      for (const word of words) {
+        this.add(word);
       }
     }
   }
 
+  protected _size: number;
+
+  get size(): number {
+    return this._size;
+  }
+
   protected _caseSensitive: boolean;
 
   get caseSensitive(): boolean {
@@ -64,6 +71,7 @@ export class Trie {
   add(word: string): boolean {
     word = this._caseProcess(word);
     let cur = this.root;
+    let isNewWord = false;
     for (const c of word) {
       let nodeC = cur.children.get(c);
       if (!nodeC) {
@@ -72,8 +80,12 @@ export class Trie {
       }
       cur = nodeC;
     }
-    cur.isEnd = true;
-    return true;
+    if (!cur.isEnd) {
+      isNewWord = true;
+      cur.isEnd = true;
+      this._size++;
+    }
+    return isNewWord;
   }
 
   /**
@@ -143,6 +155,9 @@ export class Trie {
     };
 
     dfs(this.root, 0);
+    if (isDeleted) {
+      this._size--;
+    }
     return isDeleted;
   }
 
@@ -377,6 +392,10 @@ export class Trie {
     return accumulator;
   }
 
+  print() {
+    console.log([...this]);
+  }
+
   /**
    * Time Complexity: O(M), where M is the length of the input string.
    * Space Complexity: O(1) - Constant space.

package/src/interfaces/binary-tree.ts

@@ -6,7 +6,7 @@ import {
   BiTreeDeleteResult,
   BTNCallback,
   BTNKey,
-  IterableEntriesOrKeys
+  BTNodeExemplar,
 } from '../types';
 
 export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
@@ -14,9 +14,9 @@ export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTre
 
   createTree(options?: Partial<BinaryTreeOptions>): TREE;
 
-  init(elements: IterableEntriesOrKeys<V>): void;
+  add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | null | undefined;
 
-  add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
+  addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (N | null | undefined)[];
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/src/types/common.ts

@@ -24,4 +24,14 @@ export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLeng
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
 
-export type IterableEntriesOrKeys<T> = Iterable<[BTNKey, T | undefined] | BTNKey>
+export type BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
+
+export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
+
+export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>
+
+export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>
+
+export type BTNodePureKeyOrNode<N> = BTNKey | N;
+
+export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;

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

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

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

@@ -5,8 +5,7 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
-export type HashMapOptions<K, V> = {
-  elements: Iterable<[K, V]>;
+export type HashMapOptions<K> = {
   hashFn: (key: K) => string;
   objHashFn: (key: K) => object
 }