data-structure-typed 2.1.1 → 2.2.0

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

@@ -11,6 +11,7 @@ import type {
   BinaryTreeOptions,
   BSTNOptKeyOrNode,
   EntryCallback,
+  FamilyPosition,
   IterationType,
   OptNode,
   RBTNColor,
@@ -19,7 +20,7 @@ import type {
 import { BSTOptions } from '../../types';
 import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
+import { RedBlackTree } from './red-black-tree';
 
 /**
  * RB-tree node with an extra 'count' field; keeps parent/child links.
@@ -27,8 +28,10 @@ import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
  * @template K
  * @template V
  */
-export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
-  override parent?: TreeCounterNode<K, V> = undefined;
+export class TreeCounterNode<K = any, V = any> {
+  key: K;
+  value?: V;
+  parent?: TreeCounterNode<K, V> = undefined;
 
   /**
    * Create a tree counter node.
@@ -40,18 +43,20 @@ export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
    * @returns New TreeCounterNode instance.
    */
   constructor(key: K, value?: V, count = 1, color: RBTNColor = 'BLACK') {
-    super(key, value, color);
+    this.key = key;
+    this.value = value;
+    this.color = color;
     this.count = count;
   }
 
-  override _left?: TreeCounterNode<K, V> | null | undefined = undefined;
+  _left?: TreeCounterNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the left child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Left child node, or null/undefined.
    */
-  override get left(): TreeCounterNode<K, V> | null | undefined {
+  get left(): TreeCounterNode<K, V> | null | undefined {
     return this._left;
   }
 
@@ -61,21 +66,21 @@ export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
    * @param v - New left child node, or null/undefined.
    * @returns void
    */
-  override set left(v: TreeCounterNode<K, V> | null | undefined) {
+  set left(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: TreeCounterNode<K, V> | null | undefined = undefined;
+  _right?: TreeCounterNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the right child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Right child node, or null/undefined.
    */
-  override get right(): TreeCounterNode<K, V> | null | undefined {
+  get right(): TreeCounterNode<K, V> | null | undefined {
     return this._right;
   }
 
@@ -85,12 +90,98 @@ export class TreeCounterNode<K = any, V = any> extends RedBlackTreeNode<K, V> {
    * @param v - New right child node, or null/undefined.
    * @returns void
    */
-  override set right(v: TreeCounterNode<K, V> | null | undefined) {
+  set right(v: TreeCounterNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._right = v;
   }
+
+  _height: number = 0;
+
+  /**
+   * Gets the height of the node (used in self-balancing trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The height.
+   */
+  get height(): number {
+    return this._height;
+  }
+
+  /**
+   * Sets the height of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new height.
+   */
+  set height(value: number) {
+    this._height = value;
+  }
+
+  _color: RBTNColor = 'BLACK';
+
+  /**
+   * Gets the color of the node (used in Red-Black trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The node's color.
+   */
+  get color(): RBTNColor {
+    return this._color;
+  }
+
+  /**
+   * Sets the color of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new color.
+   */
+  set color(value: RBTNColor) {
+    this._color = value;
+  }
+
+  _count: number = 1;
+
+  /**
+   * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The subtree node count.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * Sets the count of nodes in the subtree.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new count.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
+
+  /**
+   * Gets the position of the node relative to its parent.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+   */
+  get familyPosition(): FamilyPosition {
+    if (!this.parent) {
+      return this.left || this.right ? 'ROOT' : 'ISOLATED';
+    }
+
+    if (this.parent.left === this) {
+      return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
+    } else if (this.parent.right === this) {
+      return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
+    }
+
+    return 'MAL_NODE';
+  }
 }
 
 /**
@@ -142,7 +233,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     return sum;
   }
 
-  override _createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): TreeCounterNode<K, V> {
     return new TreeCounterNode(key, this._isMapMode ? undefined : value, count, color) as TreeCounterNode<K, V>;
   }
 
@@ -427,10 +518,10 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
       const [key, entryValue] = keyNodeOrEntry;
       if (key === undefined || key === null) return [undefined, undefined];
       const finalValue = value ?? entryValue;
-      return [this._createNode(key, finalValue, 'BLACK', count), finalValue];
+      return [this.createNode(key, finalValue, 'BLACK', count), finalValue];
     }
 
-    return [this._createNode(keyNodeOrEntry, value, 'BLACK', count), value];
+    return [this.createNode(keyNodeOrEntry, value, 'BLACK', count), value];
   }
 
   /**
@@ -448,7 +539,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this._createNode(key, value, color, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -6,7 +6,15 @@
  * @license MIT License
  */
 
-import type { BTNOptKeyOrNull, ElemOf, EntryCallback, RedBlackTreeOptions, TreeMultiMapOptions } from '../../types';
+import type {
+  BTNOptKeyOrNull,
+  ElemOf,
+  EntryCallback,
+  FamilyPosition,
+  RBTNColor,
+  RedBlackTreeOptions,
+  TreeMultiMapOptions
+} from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 
@@ -16,8 +24,10 @@ import { IBinaryTree } from '../../interfaces';
  * @template K
  * @template V
  */
-export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
-  override parent?: TreeMultiMapNode<K, V> = undefined;
+export class TreeMultiMapNode<K = any, V = any> {
+  key: K;
+  value?: V[];
+  parent?: TreeMultiMapNode<K, V> = undefined;
 
   /**
    * Create a TreeMultiMap node with an optional value bucket.
@@ -26,18 +36,20 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param [value] - Initial array of values.
    * @returns New TreeMultiMapNode instance.
    */
-  constructor(key: K, value?: V[]) {
-    super(key, value);
+  constructor(key: K, value: V[] = [], color: RBTNColor = 'BLACK') {
+    this.key = key;
+    this.value = value;
+    this.color = color;
   }
 
-  override _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
+  _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the left child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Left child node, or null/undefined.
    */
-  override get left(): TreeMultiMapNode<K, V> | null | undefined {
+  get left(): TreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
@@ -47,21 +59,21 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param v - New left child node, or null/undefined.
    * @returns void
    */
-  override set left(v: TreeMultiMapNode<K, V> | null | undefined) {
+  set left(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
+  _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the right child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Right child node, or null/undefined.
    */
-  override get right(): TreeMultiMapNode<K, V> | null | undefined {
+  get right(): TreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
@@ -71,12 +83,98 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param v - New right child node, or null/undefined.
    * @returns void
    */
-  override set right(v: TreeMultiMapNode<K, V> | null | undefined) {
+  set right(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._right = v;
   }
+
+  _height: number = 0;
+
+  /**
+   * Gets the height of the node (used in self-balancing trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The height.
+   */
+  get height(): number {
+    return this._height;
+  }
+
+  /**
+   * Sets the height of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new height.
+   */
+  set height(value: number) {
+    this._height = value;
+  }
+
+  _color: RBTNColor = 'BLACK';
+
+  /**
+   * Gets the color of the node (used in Red-Black trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The node's color.
+   */
+  get color(): RBTNColor {
+    return this._color;
+  }
+
+  /**
+   * Sets the color of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new color.
+   */
+  set color(value: RBTNColor) {
+    this._color = value;
+  }
+
+  _count: number = 1;
+
+  /**
+   * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The subtree node count.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * Sets the count of nodes in the subtree.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new count.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
+
+  /**
+   * Gets the position of the node relative to its parent.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+   */
+  get familyPosition(): FamilyPosition {
+    if (!this.parent) {
+      return this.left || this.right ? 'ROOT' : 'ISOLATED';
+    }
+
+    if (this.parent.left === this) {
+      return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
+    } else if (this.parent.right === this) {
+      return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
+    }
+
+    return 'MAL_NODE';
+  }
 }
 
 /**
@@ -270,10 +368,23 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     }
   }
 
-  override _createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
+  override createNode(key: K, value: V[] = []): TreeMultiMapNode<K, V> {
     return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
+  /**
+   * Checks if the given item is a `TreeMultiMapNode` instance.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param keyNodeOrEntry - The item to check.
+   * @returns True if it's a TreeMultiMapNode, false otherwise.
+   */
+  override isNode(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): keyNodeOrEntry is TreeMultiMapNode<K, V> {
+    return keyNodeOrEntry instanceof TreeMultiMapNode;
+  }
+
   override add(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;

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

@@ -50,11 +50,11 @@ export abstract class AbstractEdge<E = any> {
  * @example examples will be generated by unit test
  */
 export abstract class AbstractGraph<
-    V = any,
-    E = any,
-    VO extends AbstractVertex<V> = AbstractVertex<V>,
-    EO extends AbstractEdge<E> = AbstractEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends AbstractVertex<V> = AbstractVertex<V>,
+  EO extends AbstractEdge<E> = AbstractEdge<E>
+>
   extends IterableEntryBase<VertexKey, V | undefined>
   implements IGraph<V, E, VO, EO>
 {

package/src/data-structures/graph/directed-graph.ts

@@ -38,11 +38,11 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
  * @example examples will be generated by unit test
  */
 export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
   implements IGraph<V, E, VO, EO>
 {

package/src/data-structures/graph/undirected-graph.ts

@@ -36,11 +36,11 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
  * @example examples will be generated by unit test
  */
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
   implements IGraph<V, E, VO, EO>
 {

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

@@ -190,7 +190,7 @@ import { IterableElementBase } from '../base';
  *     ]);
  *     console.log(scheduleTasks(tasks, 2)); // expectedMap
  */
-export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
+export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
   protected _equals: (a: E, b: E) => boolean = Object.is;
 
   /**
@@ -255,7 +255,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new heap instance of this class.
    */
 
-  static from<T, R = never, S extends Heap<T, R> = Heap<T, R>>(
+  static from<T, R = any, S extends Heap<T, R> = Heap<T, R>>(
     this: new (elements?: Iterable<T | R>, options?: HeapOptions<T, R>) => S,
     elements?: Iterable<T | R>,
     options?: HeapOptions<T, R>
@@ -273,7 +273,7 @@ export class Heap<E = unknown, R = never> extends IterableElementBase<E, R> {
    * @returns A new Heap built from elements.
    */
 
-  static heapify<EE = unknown, RR = never>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
+  static heapify<EE = any, RR = any>(elements: Iterable<EE>, options: HeapOptions<EE, RR>): Heap<EE, RR> {
     return new Heap<EE, RR>(elements, options);
   }
 
@@ -788,7 +788,7 @@ export class FibonacciHeap<E> {
    */
 
   push(element: E): this {
-    const node = this._createNode(element);
+    const node = this.createNode(element);
     node.left = node;
     node.right = node;
     this.mergeWithRoot(node);
@@ -900,7 +900,7 @@ export class FibonacciHeap<E> {
     heapToMerge.clear();
   }
 
-  _createNode(element: E): FibonacciHeapNode<E> {
+  createNode(element: E): FibonacciHeapNode<E> {
     return new FibonacciHeapNode<E>(element);
   }
 

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

@@ -781,7 +781,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    * @returns A new SinglyLinkedListNode instance.
    */
 
-  protected _createNode(value: E): SinglyLinkedListNode<E> {
+  protected createNode(value: E): SinglyLinkedListNode<E> {
     return new SinglyLinkedListNode<E>(value);
   }
 
@@ -807,7 +807,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
 
   protected _ensureNode(elementOrNode: E | SinglyLinkedListNode<E>) {
     if (this.isNode(elementOrNode)) return elementOrNode;
-    return this._createNode(elementOrNode);
+    return this.createNode(elementOrNode);
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -32,7 +32,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
   readonly isDuplicate: boolean;
 
   // ---- construction / mutation ----
-  _createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
+  createNode(key: K, value?: BinaryTreeNode<K, V>['value']): BinaryTreeNode<K, V>;
 
   createTree(options?: Partial<BinaryTreeOptions<K, V, R>>): IBinaryTree<K, V, R>;
 

package/test/integration/compile.test.mjs

@@ -0,0 +1,159 @@
+import {
+  AVLTree,
+  BinaryTree,
+  BST,
+  Deque,
+  DoublyLinkedList,
+  HashMap,
+  Heap,
+  MaxPriorityQueue,
+  MinHeap,
+  MinPriorityQueue,
+  Queue,
+  RedBlackTree,
+  SinglyLinkedList,
+  Stack,
+  TreeMultiMap,
+  Trie
+} from 'data-structure-typed';
+
+describe('', () => {
+  it('', () => {
+    const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+    const orgStrArr = ['trie', 'trial', 'trick', 'trip', 'tree', 'trend', 'triangle', 'track', 'trace', 'transmit'];
+    const entries = [
+      [6, '6'],
+      [1, '1'],
+      [2, '2'],
+      [7, '7'],
+      [5, '5'],
+      [3, '3'],
+      [4, '4'],
+      [9, '9'],
+      [8, '8']
+    ];
+    const queue = new Queue(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const deque = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const sList = new SinglyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const dList = new DoublyLinkedList(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const stack = new Stack(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const minHeap = new MinHeap(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const maxPQ = new MaxPriorityQueue(orgArr);
+
+    // [9, 8, 4, 7, 5, 2, 3, 1, 6]
+    const biTree = new BinaryTree(entries);
+
+    //         ___6___
+    //        /       \
+    //     ___1_     _2_
+    //    /     \   /   \
+    //   _7_    5   3   4
+    //  /   \
+    //  9   8
+    const bst = new BST(entries);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const rbTree = new RedBlackTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const avl = new AVLTree(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const treeMulti = new TreeMultiMap(entries);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const hm = new HashMap(entries);
+
+    // [[6, "6"], [1, "1"], [2, "2"], [7, "7"], [5, "5"], [3, "3"], [4, "4"], [9, "9"], [8, "8"]]
+    const rbTreeH = new RedBlackTree(hm);
+
+    //     ___4___
+    //    /       \
+    //   _2_     _6___
+    //  /   \   /     \
+    //  1   3   5    _8_
+    //              /   \
+    //              7   9
+    const pq = new MinPriorityQueue(orgArr);
+
+    // [1, 5, 2, 7, 6, 3, 4, 9, 8]
+    const bst1 = new BST(pq);
+
+    //     _____5___
+    //    /         \
+    //   _2_       _7_
+    //  /   \     /   \
+    //  1   3_    6   8_
+    //        \         \
+    //        4         9
+    const dq1 = new Deque(orgArr);
+
+    // [6, 1, 2, 7, 5, 3, 4, 9, 8]
+    const rbTree1 = new RedBlackTree(dq1);
+
+    //    _____5___
+    //   /         \
+    //  _2___     _7___
+    // /     \   /     \
+    // 1    _4   6    _9
+    //      /         /
+    //      3         8
+    const trie2 = new Trie(orgStrArr);
+
+    // ['trie', 'trial', 'triangle', 'trick', 'trip', 'tree', 'trend', 'track', 'trace', 'transmit']
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const dq2 = new Deque(heap2);
+
+    // ['transmit', 'trace', 'tree', 'trend', 'track', 'trial', 'trip', 'trie', 'trick', 'triangle']
+    const entries2 = dq2.map((el, i) => [i, el]);
+    const avl2 = new AVLTree(entries2);
+    avl2.print();
+    //     ___3_______
+    //    /           \
+    //   _1_       ___7_
+    //  /   \     /     \
+    //  0   2    _5_    8_
+    //          /   \     \
+    //          4   6     9
+
+    expect(avl2.size).toBe(10);
+  });
+});