queue-typed 1.49.0 → 1.49.1

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

@@ -1,6 +1,3 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
-
 /**
  * data-structure-typed
  *
@@ -8,6 +5,9 @@ import { ElementCallback } from "../../types";
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
+
 export class DoublyLinkedListNode<E = any> {
   value: E;
   next: DoublyLinkedListNode<E> | undefined;
@@ -25,6 +25,12 @@ export class DoublyLinkedListNode<E = any> {
   }
 }
 
+/**
+ * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
+ * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
+ * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ */
 export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes the linked list with an empty head, tail, and length.

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

@@ -1,6 +1,3 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
-
 /**
  * data-structure-typed
  *
@@ -8,6 +5,9 @@ import { ElementCallback } from "../../types";
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { ElementCallback } from "../../types";
+import { IterableElementBase } from "../base";
+
 export class SinglyLinkedListNode<E = any> {
   value: E;
   next: SinglyLinkedListNode<E> | undefined;

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
+import { PriorityQueue } from './priority-queue';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
+import { PriorityQueue } from './priority-queue';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(elements?: Iterable<E>,

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

@@ -5,10 +5,17 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-
+import type { PriorityQueueOptions } from '../../types';
 import { Heap } from '../heap';
-import { PriorityQueueOptions } from '../../types';
 
+/**
+ * 1. Element Priority: In a PriorityQueue, elements are sorted according to their priority. Each dequeue (element removal) operation removes the element with the highest priority. The priority can be determined based on the natural ordering of the elements or through a provided comparator (Comparator).
+ * 2. Heap-Based Implementation: PriorityQueue is typically implemented using a binary heap, allowing both insertion and removal operations to be completed in O(log n) time, where n is the number of elements in the queue.
+ * 3. Task Scheduling: In systems where tasks need to be processed based on the urgency of tasks rather than the order of arrival.
+ * 4. Dijkstra's Algorithm: In shortest path algorithms for graphs, used to select the next shortest edge to visit.
+ * 5. Huffman Coding: Used to select the smallest node combination when constructing a Huffman tree.
+ * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
+ */
 export class PriorityQueue<E = any> extends Heap<E> {
   constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>) {
     super(elements, options);

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

@@ -5,19 +5,17 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
-
-import { ElementCallback, IterableWithSizeOrLength } from "../../types";
-import { calcMinUnitsRequired, rangeCheck } from "../../utils";
+import type { ElementCallback, IterableWithSizeOrLength } from "../../types";
 import { IterableElementBase } from "../base";
+import { calcMinUnitsRequired, rangeCheck } from "../../utils";
 
 /**
- * Deque can provide random access with O(1) time complexity
- * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
- * Deque may experience performance jitter, but DoublyLinkedList will not
- * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
+ * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
+ * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
+ * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
+ * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
+ * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
-
 export class Deque<E> extends IterableElementBase<E> {
   protected _bucketFirst = 0;
   protected _firstInBucket = 0;

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

@@ -3,10 +3,19 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import { SinglyLinkedList } from '../linked-list';
+import type { ElementCallback } from '../../types';
 import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+import { SinglyLinkedList } from '../linked-list';
 
+/**
+ * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
+ * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
+ * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
+ * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
+ * 5. Data Buffering: Acting as a buffer for data packets in network communication.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
+ */
 export class Queue<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
@@ -179,7 +188,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @param {E} value - The value parameter represents the value that you want to add to the queue.
    */
   enqueue(value: E) {
-    this.push(value);
+    return this.push(value);
   }
 
   /**
@@ -346,6 +355,12 @@ export class Queue<E = any> extends IterableElementBase<E> {
   }
 }
 
+/**
+ * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
+ * 2. Based on Linked List: LinkedListQueue uses a linked list to store elements. Each node in the linked list contains data and a pointer to the next node.
+ * 3. Memory Usage: Since each element requires additional space to store a pointer to the next element, linked lists may use more memory compared to arrays.
+ * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
+ */
 export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
   /**
    * The enqueue function adds a value to the end of an array.

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

@@ -1,10 +1,20 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 
 /**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
+ * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.
+ * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.
+ * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.
+ * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
+ * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
+ * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
 export class Stack<E = any> extends IterableElementBase<E> {
   /**
@@ -115,7 +125,7 @@ export class Stack<E = any> extends IterableElementBase<E> {
   pop(): E | undefined {
     if (this.isEmpty()) return undefined;
 
-    return this.elements.pop() || undefined;
+    return this.elements.pop();
   }
 
   /**

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

@@ -5,9 +5,8 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
 
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
@@ -26,7 +25,17 @@ export class TrieNode {
 }
 
 /**
- * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ * 1. Node Structure: Each node in a Trie represents a string (or a part of a string). The root node typically represents an empty string.
+ * 2. Child Node Relationship: Each node's children represent the strings that can be formed by adding one character to the string at the current node. For example, if a node represents the string 'ca', one of its children might represent 'cat'.
+ * 3. Fast Retrieval: Trie allows retrieval in O(m) time complexity, where m is the length of the string to be searched.
+ * 4. Space Efficiency: Trie can store a large number of strings very space-efficiently, especially when these strings share common prefixes.
+ * 5. Autocomplete and Prediction: Trie can be used for implementing autocomplete and word prediction features, as it can quickly find all strings with a common prefix.
+ * 6. Sorting: Trie can be used to sort a set of strings in alphabetical order.
+ * 7. String Retrieval: For example, searching for a specific string in a large set of strings.
+ * 8. Autocomplete: Providing recommended words or phrases as a user types.
+ * 9. Spell Check: Checking the spelling of words.
+ * 10. IP Routing: Used in certain types of IP routing algorithms.
+ * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends IterableElementBase<string> {
   constructor(words?: string[], caseSensitive = true) {

package/src/interfaces/binary-tree.ts

@@ -1,11 +1,11 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
 import {
+  BinaryTreeDeleteResult,
   BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
-  BiTreeDeleteResult,
   BTNCallback,
-  BTNodeExemplar,
+  BTNExemplar,
 } from '../types';
 
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
@@ -13,9 +13,9 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
 
-  add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
+  add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
 
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+  addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
 
-  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
+  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/src/types/common.ts

@@ -1,20 +1,43 @@
-export type Comparator<K> = (a: K, b: K) => number;
-
 export enum BSTVariant {
   MIN = 'MIN',
   MAX = 'MAX',
 }
 
-export type DFSOrderPattern = 'pre' | 'in' | 'post';
-
-export type BTNCallback<N, D = any> = (node: N) => D;
-
 export enum CP {
   lt = 'lt',
   eq = 'eq',
   gt = 'gt'
 }
 
+/**
+ * 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 enum IterationType {
+  ITERATIVE = 'ITERATIVE',
+  RECURSIVE = '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 Comparator<K> = (a: K, b: K) => number;
+
+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);
 }
@@ -27,14 +50,16 @@ export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLeng
 
 export type BinaryTreePrintOptions = { isShowUndefined?: boolean, isShowNull?: boolean, isShowRedBlackNIL?: boolean }
 
-export type BTNodeEntry<K, V> = [K | null | undefined, V | undefined];
-
-export type BTNodeKeyOrNode<K, N> = K | null | undefined | N;
+export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 
-export type BTNodeExemplar<K, V, N> = BTNodeEntry<K, V> | BTNodeKeyOrNode<K, N>
+export type BTNKeyOrNode<K, N> = K | null | undefined | N;
 
-export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>
+export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>
 
 export type BTNodePureKeyOrNode<K, N> = K | N;
 
-export type BSTNodeKeyOrNode<K, N> = K | undefined | N;
+export type BTNodePureExemplar<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 };

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

@@ -5,5 +5,4 @@ export type AVLTreeNodeNested<K, V> = AVLTreeNode<K, V, AVLTreeNode<K, V, AVLTre
 
 export type AVLTreeNested<K, V, N extends AVLTreeNode<K, V, N>> = AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, AVLTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-
 export type AVLTreeOptions<K> = BSTOptions<K> & {};

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

@@ -1,28 +1,5 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
-
-/**
- * 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 enum IterationType {
-  ITERATIVE = 'ITERATIVE',
-  RECURSIVE = '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 BiTreeDeleteResult<N> = { deleted: N | null | undefined; needBalanced: N | null | undefined };
+import { IterationType } 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>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
@@ -32,5 +9,3 @@ export type BinaryTreeOptions<K> = {
   iterationType: IterationType,
   extractor: (key: K) => number
 }
-
-export type NodeDisplayLayout = [string[], number, number, number];

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

@@ -2,7 +2,6 @@ import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
 import { BSTVariant } from "../../common";
 
-// prettier-ignore
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTNested<K, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

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

@@ -1,5 +1,5 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
-import { BSTOptions } from "./bst";
+import type { BSTOptions } from "./bst";
 
 export enum RBTNColor { RED = 1, BLACK = 0}
 

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

@@ -1,5 +1,5 @@
 import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
-import { AVLTreeOptions } from './avl-tree';
+import type { AVLTreeOptions } from './avl-tree';
 
 export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>