data-structure-typed 1.40.0-rc → 1.41.0

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

@@ -22,12 +22,20 @@ export class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
     return this.shift();
   }
 
+  /**
+   * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+   * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+   */
+  getFirst(): E | undefined {
+    return this.head?.value;
+  }
+
   /**
    * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
    * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
    */
   peek(): E | undefined {
-    return this.head?.val;
+    return this.getFirst();
   }
 }
 
@@ -43,26 +51,18 @@ export class Queue<E = any> {
     this._offset = 0;
   }
 
-  private _nodes: E[];
+  protected _nodes: E[];
 
   get nodes(): E[] {
     return this._nodes;
   }
 
-  set nodes(value: E[]) {
-    this._nodes = value;
-  }
-
-  private _offset: number;
+  protected _offset: number;
 
   get offset(): number {
     return this._offset;
   }
 
-  set offset(value: number) {
-    this._offset = value;
-  }
-
   /**
    * The size function returns the number of elements in an array.
    * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
@@ -101,25 +101,43 @@ export class Queue<E = any> {
   shift(): E | undefined {
     if (this.size === 0) return undefined;
 
-    const first = this.peek();
-    this.offset += 1;
+    const first = this.getFirst();
+    this._offset += 1;
 
     if (this.offset * 2 < this.nodes.length) return first;
 
-    // only remove dequeued elements when reaching half size
+    // only delete dequeued elements when reaching half size
     // to decrease latency of shifting elements.
-    this.nodes = this.nodes.slice(this.offset);
-    this.offset = 0;
+    this._nodes = this.nodes.slice(this.offset);
+    this._offset = 0;
     return first;
   }
 
+  /**
+   * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+   * @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`.
+   */
+  getFirst(): E | undefined {
+    return this.size > 0 ? this.nodes[this.offset] : undefined;
+  }
+
   /**
    * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
    * @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`.
    */
   peek(): E | undefined {
-    return this.size > 0 ? this.nodes[this.offset] : undefined;
+    return this.getFirst();
+  }
+
+  /**
+   * The `getLast` function returns the last element in an array-like data structure, or null 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`.
+   */
+  getLast(): E | undefined {
+    return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
   }
 
   /**
@@ -128,7 +146,7 @@ export class Queue<E = any> {
    * array is empty, it returns `null`.
    */
   peekLast(): E | undefined {
-    return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    return this.getLast();
   }
 
   /**
@@ -171,8 +189,8 @@ export class Queue<E = any> {
    * The clear function resets the nodes array and offset to their initial values.
    */
   clear(): void {
-    this.nodes = [];
-    this.offset = 0;
+    this._nodes = [];
+    this._offset = 0;
   }
 
   /**
@@ -183,7 +201,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  *[Symbol.iterator]() {
+  * [Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

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

@@ -4,8 +4,6 @@
  * @class
  */
 export class Stack<E = any> {
-  protected _elements: E[];
-
   /**
    * The constructor initializes an array of elements, which can be provided as an optional parameter.
    * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
@@ -16,6 +14,12 @@ export class Stack<E = any> {
     this._elements = Array.isArray(elements) ? elements : [];
   }
 
+  protected _elements: E[];
+
+  get elements(): E[] {
+    return this._elements;
+  }
+
   /**
    * The function "fromArray" creates a new Stack object from an array of elements.
    * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
@@ -31,7 +35,7 @@ export class Stack<E = any> {
    * @returns A boolean value indicating whether the `_elements` array is empty or not.
    */
   isEmpty(): boolean {
-    return this._elements.length === 0;
+    return this.elements.length === 0;
   }
 
   /**
@@ -39,7 +43,7 @@ export class Stack<E = any> {
    * @returns The size of the elements array.
    */
   size(): number {
-    return this._elements.length;
+    return this.elements.length;
   }
 
   /**
@@ -49,7 +53,7 @@ export class Stack<E = any> {
   peek(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements[this._elements.length - 1];
+    return this.elements[this.elements.length - 1];
   }
 
   /**
@@ -58,7 +62,7 @@ export class Stack<E = any> {
    * @returns The `push` method is returning the updated `Stack<E>` object.
    */
   push(element: E): Stack<E> {
-    this._elements.push(element);
+    this.elements.push(element);
     return this;
   }
 
@@ -70,7 +74,7 @@ export class Stack<E = any> {
   pop(): E | null {
     if (this.isEmpty()) return null;
 
-    return this._elements.pop() || null;
+    return this.elements.pop() || null;
   }
 
   /**
@@ -78,7 +82,7 @@ export class Stack<E = any> {
    * @returns An array of type E.
    */
   toArray(): E[] {
-    return this._elements.slice();
+    return this.elements.slice();
   }
 
   /**
@@ -93,6 +97,6 @@ export class Stack<E = any> {
    * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
    */
   clone(): Stack<E> {
-    return new Stack(this._elements.slice());
+    return new Stack(this.elements.slice());
   }
 }

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

@@ -1,38 +1,12 @@
 export class TreeNode<V = any> {
-  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
-    this._key = key;
-    this._value = value || undefined;
-    this._children = children || [];
-  }
-
-  private _key: string;
-
-  get key(): string {
-    return this._key;
-  }
-
-  set key(value: string) {
-    this._key = value;
-  }
-
-  private _value?: V | undefined;
+  key: string;
+  value?: V | undefined;
+  children?: TreeNode<V>[] | undefined;
 
-  get value(): V | undefined {
-    return this._value;
-  }
-
-  set value(value: V | undefined) {
-    this._value = value;
-  }
-
-  private _children?: TreeNode<V>[] | undefined;
-
-  get children(): TreeNode<V>[] | undefined {
-    return this._children;
-  }
-
-  set children(value: TreeNode<V>[] | undefined) {
-    this._children = value;
+  constructor(key: string, value?: V, children?: TreeNode<V>[]) {
+    this.key = key;
+    this.value = value || undefined;
+    this.children = children || [];
   }
 
   addChildren(children: TreeNode<V> | TreeNode<V>[]) {
@@ -47,10 +21,8 @@ export class TreeNode<V = any> {
   }
 
   getHeight() {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const beginRoot = this;
-    let maxDepth = 1;
-    if (beginRoot) {
+    let maxDepth = 0;
+    if (this) {
       const bfs = (node: TreeNode<V>, level: number) => {
         if (level > maxDepth) {
           maxDepth = level;
@@ -62,7 +34,7 @@ export class TreeNode<V = any> {
           }
         }
       };
-      bfs(beginRoot, 1);
+      bfs(this, 0);
     }
     return maxDepth;
   }

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

@@ -5,47 +5,30 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class TrieNode {
-  constructor(v: string) {
-    this._val = v;
-    this._isEnd = false;
-    this._children = new Map<string, TrieNode>();
-  }
-
-  private _val;
 
-  get val(): string {
-    return this._val;
-  }
-
-  set val(v: string) {
-    this._val = v;
-  }
-
-  protected _children: Map<string, TrieNode>;
-
-  get children(): Map<string, TrieNode> {
-    return this._children;
-  }
-
-  set children(v: Map<string, TrieNode>) {
-    this._children = v;
-  }
-
-  protected _isEnd: boolean;
-
-  get isEnd(): boolean {
-    return this._isEnd;
-  }
+/**
+ * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
+ * and a flag indicating whether it's the end of a word.
+ */
+export class TrieNode {
+  key: string;
+  children: Map<string, TrieNode>;
+  isEnd: boolean;
 
-  set isEnd(v: boolean) {
-    this._isEnd = v;
+  constructor(key: string) {
+    this.key = key;
+    this.isEnd = false;
+    this.children = new Map<string, TrieNode>();
   }
 }
 
+/**
+ * Trie represents a Trie data structure. It provides basic Trie operations and additional methods.
+ */
 export class Trie {
-  constructor(words?: string[]) {
+  constructor(words?: string[], caseSensitive = true) {
     this._root = new TrieNode('');
+    this._caseSensitive = caseSensitive;
     if (words) {
       for (const i of words) {
         this.add(i);
@@ -53,18 +36,26 @@ export class Trie {
     }
   }
 
+  protected _caseSensitive: boolean;
+
+  get caseSensitive(): boolean {
+    return this._caseSensitive;
+  }
+
   protected _root: TrieNode;
 
   get root() {
     return this._root;
   }
 
-  set root(v: TrieNode) {
-    this._root = v;
-  }
-
+  /**
+   * Add a word to the Trie structure.
+   * @param {string} word - The word to add.
+   * @returns {boolean} True if the word was successfully added.
+   */
   add(word: string): boolean {
-    let cur = this._root;
+    word = this._caseProcess(word);
+    let cur = this.root;
     for (const c of word) {
       let nodeC = cur.children.get(c);
       if (!nodeC) {
@@ -77,9 +68,15 @@ export class Trie {
     return true;
   }
 
-  has(input: string): boolean {
-    let cur = this._root;
-    for (const c of input) {
+  /**
+   * Check if the Trie contains a given word.
+   * @param {string} word - The word to check for.
+   * @returns {boolean} True if the word is present in the Trie.
+   */
+  has(word: string): boolean {
+    word = this._caseProcess(word);
+    let cur = this.root;
+    for (const c of word) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
       cur = nodeC;
@@ -87,7 +84,13 @@ export class Trie {
     return cur.isEnd;
   }
 
-  remove(word: string) {
+  /**
+   * Remove a word from the Trie structure.
+   * @param{string} word - The word to delete.
+   * @returns {boolean} True if the word was successfully removed.
+   */
+  delete(word: string) {
+    word = this._caseProcess(word);
     let isDeleted = false;
     const dfs = (cur: TrieNode, i: number): boolean => {
       const char = word[i];
@@ -119,14 +122,35 @@ export class Trie {
     return isDeleted;
   }
 
+  getHeight() {
+    const beginRoot = this.root;
+    let maxDepth = 0;
+    if (beginRoot) {
+      const bfs = (node: TrieNode, level: number) => {
+        if (level > maxDepth) {
+          maxDepth = level;
+        }
+        const {children} = node;
+        if (children) {
+          for (const child of children.entries()) {
+            bfs(child[1], level + 1);
+          }
+        }
+      };
+      bfs(beginRoot, 0);
+    }
+    return maxDepth;
+  }
+
   // --- start additional methods ---
   /**
-   * The function checks if a given input string has an absolute prefix in a tree data structure.Only can present as a prefix, not a word
-   * @param {string} input - The input parameter is a string that represents the input value for the function.
-   * @returns a boolean value.
+   * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
+   * @param {string} input - The input string to check.
+   * @returns {boolean} True if it's an absolute prefix in the Trie.
    */
-  isAbsPrefix(input: string): boolean {
-    let cur = this._root;
+  hasPurePrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
     for (const c of input) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
@@ -136,12 +160,13 @@ export class Trie {
   }
 
   /**
-   * The function checks if a given input string is a prefix of any existing string in a tree structure.Can present as a abs prefix or word
-   * @param {string} input - The input parameter is a string that represents the prefix we want to check.
-   * @returns a boolean value.
+   * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
+   * @param {string} input - The input string representing the prefix to check.
+   * @returns {boolean} True if it's a prefix in the Trie.
    */
-  isPrefix(input: string): boolean {
-    let cur = this._root;
+  hasPrefix(input: string): boolean {
+    input = this._caseProcess(input);
+    let cur = this.root;
     for (const c of input) {
       const nodeC = cur.children.get(c);
       if (!nodeC) return false;
@@ -151,50 +176,52 @@ export class Trie {
   }
 
   /**
-   * The function checks if the input string is a common prefix in a Trie data structure.Check if the input string is the common prefix of all the words
-   * @param {string} input - The input parameter is a string that represents the common prefix that we want to check for
-   * in the Trie data structure.
-   * @returns a boolean value indicating whether the input string is a common prefix in the Trie data structure.
+   * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
+   * @param {string} input - The input string representing the common prefix to check for.
+   * @returns {boolean} True if it's a common prefix in the Trie.
    */
-  isCommonPrefix(input: string): boolean {
+  hasCommonPrefix(input: string): boolean {
+    input = this._caseProcess(input);
     let commonPre = '';
     const dfs = (cur: TrieNode) => {
-      commonPre += cur.val;
+      commonPre += cur.key;
       if (commonPre === input) return;
       if (cur.isEnd) return;
       if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
       else return;
     };
-    dfs(this._root);
+    dfs(this.root);
     return commonPre === input;
   }
 
   /**
-   * The function `getLongestCommonPrefix` returns the longest common prefix among all the words stored in a Trie data
-   * structure.
-   * @returns The function `getLongestCommonPrefix` returns a string, which is the longest common prefix found in the
-   * Trie.
+   * Get the longest common prefix among all the words stored in the Trie.
+   * @returns {string} The longest common prefix found in the Trie.
    */
   getLongestCommonPrefix(): string {
     let commonPre = '';
     const dfs = (cur: TrieNode) => {
-      commonPre += cur.val;
+      commonPre += cur.key;
       if (cur.isEnd) return;
       if (cur && cur.children && cur.children.size === 1) dfs(Array.from(cur.children.values())[0]);
       else return;
     };
-    dfs(this._root);
+    dfs(this.root);
     return commonPre;
   }
 
   /**
    * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
-   * @param [prefix] - The `prefix` parameter is a string that represents the prefix that we want to search for in the
+   * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
    * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
-   * @returns an array of strings.
+   * @param {number} max - The max count of words will be found
+   * @param isAllWhenEmptyPrefix - If true, when the prefix provided as '', returns all the words in the trie.
+   * @returns {string[]} an array of strings.
    */
-  getAll(prefix = ''): string[] {
+  getWords(prefix = '', max = Number.MAX_SAFE_INTEGER, isAllWhenEmptyPrefix = false): string[] {
+    prefix = this._caseProcess(prefix);
     const words: string[] = [];
+    let found = 0;
 
     function dfs(node: TrieNode, word: string) {
       for (const char of node.children.keys()) {
@@ -204,11 +231,13 @@ export class Trie {
         }
       }
       if (node.isEnd) {
+        if (found > max - 1) return;
         words.push(word);
+        found++;
       }
     }
 
-    let startNode = this._root;
+    let startNode = this.root;
 
     if (prefix) {
       for (const c of prefix) {
@@ -217,9 +246,17 @@ export class Trie {
       }
     }
 
-    dfs(startNode, prefix);
+    if (isAllWhenEmptyPrefix || startNode !== this.root) dfs(startNode, prefix);
+
     return words;
   }
 
+  protected _caseProcess(str: string) {
+    if (!this._caseSensitive) {
+      str = str.toLowerCase(); // Convert str to lowercase if case-insensitive
+    }
+    return str;
+  }
+
   // --- end additional methods ---
 }

package/src/interfaces/binary-tree.ts

@@ -1,7 +1,10 @@
 import {BinaryTreeNode} from '../data-structures';
-import {IAbstractBinaryTree, IAbstractBinaryTreeNode} from './abstract-binary-tree';
+import {BinaryTreeDeletedResult, BinaryTreeNodeNested, BTNCallback, BTNKey} from '../types';
 
-export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>>
-  extends IAbstractBinaryTreeNode<T, NEIGHBOR> {}
+export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>> {
+  createNode(key: BTNKey, value?: N['value']): N;
 
-export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {}
+  add(keyOrNode: BTNKey | N | null, value?: N['value']): N | null | undefined;
+
+  delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeletedResult<N>[];
+}

package/src/interfaces/graph.ts

@@ -0,0 +1,7 @@
+import {VertexKey} from '../types';
+
+export interface IGraph<V, E, VO, EO> {
+  createVertex(key: VertexKey, value?: V): VO;
+
+  createEdge(srcOrV1: VertexKey, destOrV2: VertexKey, weight?: number, value?: E): EO;
+}

package/src/interfaces/index.ts

@@ -1,15 +1,8 @@
-export * from './abstract-binary-tree';
-export * from './abstract-graph';
-export * from './avl-tree';
+export * from './graph';
 export * from './binary-tree';
-export * from './bst';
-export * from './directed-graph';
 export * from './doubly-linked-list';
 export * from './heap';
 export * from './navigator';
 export * from './priority-queue';
-export * from './rb-tree';
 export * from './segment-tree';
 export * from './singly-linked-list';
-export * from './tree-multiset';
-export * from './undirected-graph';

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

@@ -0,0 +1,5 @@
+import {AVLTreeNode} from '../../../data-structures';
+import {BSTOptions} from './bst';
+
+export type AVLTreeNodeNested<T> = AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, AVLTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type AVLTreeOptions = BSTOptions & {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+import {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 BTNKey = number;
+
+export type BinaryTreeDeletedResult<N> = { deleted: N | null | undefined; needBalanced: N | null };
+
+export type BinaryTreeNodeNested<T> = BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, BinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type BinaryTreeOptions = { iterationType?: IterationType }

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

@@ -0,0 +1,11 @@
+import {BSTNode} from '../../../data-structures';
+import type {BinaryTreeOptions, BTNKey} from './binary-tree';
+
+export type BSTComparator = (a: BTNKey, b: BTNKey) => number;
+
+// prettier-ignore
+export type BSTNodeNested<T> = BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+export type BSTOptions = BinaryTreeOptions & {
+  comparator?: BSTComparator,
+}

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

@@ -0,0 +1,6 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './avl-tree';
+export * from './segment-tree';
+export * from './tree-multiset';
+export * from './rb-tree';