bst-typed 1.50.7 → 1.50.9

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

@@ -9,12 +9,13 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
   TreeMultiMapOptions
 } from '../../types';
-import { IterationType, RBTNColor } from '../../types';
+import { RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 
@@ -24,17 +25,19 @@ export class TreeMultiMapNode<
   NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>
 > extends RedBlackTreeNode<K, V, NODE> {
   /**
-   * The constructor function initializes an instance of a class with a key, value, and count.
-   * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-   * constructor. It is required and must be provided when creating an instance of the class.
-   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-   * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-   * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-   * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-   * 1.
+   * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
+   * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
+   * used to identify and locate the node within the tree.
+   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+   * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+   * creating a new node.
+   * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+   * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+   * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+   * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
    */
-  constructor(key: K, value?: V, count = 1) {
-    super(key, value);
+  constructor(key: K, value?: V, count = 1, color: RBTNColor = 'BLACK') {
+    super(key, value, color);
     this.count = count;
   }
 
@@ -91,25 +94,41 @@ export class TreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
   }
 
   /**
-   * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
+   * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
    * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-   * which is a generic type that can be replaced with any specific type when using the function.
-   * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-   * associated with the key in the node. It is of type `V`, which can be any data type.
-   * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-   * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-   * default to 1.
-   * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+   * which is a generic type representing the key type of the node.
+   * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+   * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+   * function. If provided, it should be of type `V`.
+   * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+   * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+   * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+   * the tree. It is an optional parameter and is used to keep track of the number of values associated
+   * with a key in the tree.
+   * @returns A new instance of the TreeMultiMapNode class is being returned.
    */
-  override createNode(key: K, value?: V, count?: number): NODE {
-    return new TreeMultiMapNode(key, value, count) as NODE;
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK', count?: number): NODE {
+    return new TreeMultiMapNode(key, value, count, color) as NODE;
   }
 
   /**
@@ -153,10 +172,10 @@ export class TreeMultiMap<
       if (key === undefined || key === null) {
         return;
       } else {
-        node = this.createNode(key, value, count);
+        node = this.createNode(key, value, 'BLACK', count);
       }
     } else if (!this.isNode(keyOrNodeOrEntry)) {
-      node = this.createNode(keyOrNodeOrEntry, value, count);
+      node = this.createNode(keyOrNodeOrEntry, value, 'BLACK', count);
     } else {
       return;
     }
@@ -314,7 +333,7 @@ export class TreeMultiMap<
     this._size--;
 
     // If the original color was black, fix the tree
-    if (originalColor === RBTNColor.BLACK) {
+    if (originalColor === 'BLACK') {
       this._deleteFixup(replacementNode);
     }
 
@@ -356,14 +375,14 @@ export class TreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
     this.clear();
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
@@ -431,7 +450,7 @@ export class TreeMultiMap<
     destNode = this.ensureNode(destNode);
     if (srcNode && destNode) {
       const { key, value, count, color } = destNode;
-      const tempNode = this.createNode(key, value, count);
+      const tempNode = this.createNode(key, value, color, count);
       if (tempNode) {
         tempNode.color = color;
 

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

@@ -247,10 +247,10 @@ export class Heap<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(log n)
    *
    * Depth-first search (DFS) method, different traversal orders can be selected。
-   * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+   * @param order - Traverse order parameter: 'IN' (in-order), 'PRE' (pre-order) or 'POST' (post-order).
    * @returns An array containing elements traversed in the specified order.
    */
-  dfs(order: DFSOrderPattern = 'pre'): E[] {
+  dfs(order: DFSOrderPattern = 'PRE'): E[] {
     const result: E[] = [];
 
     // Auxiliary recursive function, traverses the binary heap according to the traversal order
@@ -258,15 +258,15 @@ export class Heap<E = any> extends IterableElementBase<E> {
       const left = 2 * index + 1,
         right = left + 1;
       if (index < this.size) {
-        if (order === 'in') {
+        if (order === 'IN') {
           _dfs(left);
           result.push(this.elements[index]);
           _dfs(right);
-        } else if (order === 'pre') {
+        } else if (order === 'PRE') {
           result.push(this.elements[index]);
           _dfs(left);
           _dfs(right);
-        } else if (order === 'post') {
+        } else if (order === 'POST') {
           _dfs(left);
           _dfs(right);
           result.push(this.elements[index]);

package/src/types/common.ts

@@ -1,13 +1,5 @@
-export enum BSTVariant {
-  STANDARD = 'STANDARD',
-  INVERSE = 'INVERSE'
-}
-
-export enum CP {
-  lt = 'lt',
-  eq = 'eq',
-  gt = 'gt'
-}
+export type BSTVariant = 'STANDARD' | 'INVERSE';
+export type CP = 'LT' | 'EQ' | 'GT';
 
 /**
  * Enum representing different loop types.
@@ -15,24 +7,13 @@ export enum CP {
  * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
  * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
  */
-export enum IterationType {
-  ITERATIVE = 'ITERATIVE',
-  RECURSIVE = 'RECURSIVE'
-}
+export type IterationType = 'ITERATIVE' | 'RECURSIVE';
 
-export enum FamilyPosition {
-  ROOT = 'ROOT',
-  LEFT = 'LEFT',
-  RIGHT = 'RIGHT',
-  ROOT_LEFT = 'ROOT_LEFT',
-  ROOT_RIGHT = 'ROOT_RIGHT',
-  ISOLATED = 'ISOLATED',
-  MAL_NODE = 'MAL_NODE'
-}
+export type FamilyPosition = 'ROOT' | 'LEFT' | 'RIGHT' | 'ROOT_LEFT' | 'ROOT_RIGHT' | 'ISOLATED' | 'MAL_NODE';
 
 export type Comparator<K> = (a: K, b: K) => number;
 
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
+export type DFSOrderPattern = 'PRE' | 'IN' | 'POST';
 
 export type NodeDisplayLayout = [string[], number, number, number];
 
@@ -64,9 +45,4 @@ export type BSTNKeyOrNode<K, N> = K | undefined | N;
 
 export type BinaryTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
 
-export enum CRUD {
-  CREATED = 'CREATED',
-  READ = 'READ',
-  UPDATED = 'UPDATED',
-  DELETED = 'DELETED'
-}
+export type CRUD = 'CREATED' | 'READ' | 'UPDATED' | 'DELETED';

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

@@ -1,7 +1,7 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
 
-export enum RBTNColor { RED = 1, BLACK = 0}
+export type RBTNColor = 'RED' | 'BLACK';
 
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>