data-structure-typed 1.36.1 → 1.36.3

package/lib/data-structures/binary-tree/binary-tree.js

@@ -5,10 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { AbstractBinaryTree, AbstractBinaryTreeNode } from './abstract-binary-tree';
 import { FamilyPosition, LoopType } from '../../types';
 import { trampoline } from '../../utils';
-export class BinaryTreeNode extends AbstractBinaryTreeNode {
+export class BinaryTreeNode {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key and an optional value.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -17,8 +16,8 @@ export class BinaryTreeNode extends AbstractBinaryTreeNode {
      * stored in the binary tree node. If no value is provided, it will be set to undefined.
      */
     constructor(key, val) {
-        super(val);
         this.key = key;
+        this.val = val;
     }
     get left() {
         return this._left;
@@ -75,7 +74,7 @@ export class BinaryTreeNode extends AbstractBinaryTreeNode {
         }
     }
 }
-export class BinaryTree extends AbstractBinaryTree {
+export class BinaryTree {
     /**
      * This is a constructor function for a binary tree class that takes an optional options parameter.
      * @param {BinaryTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the
@@ -83,7 +82,6 @@ export class BinaryTree extends AbstractBinaryTree {
      * different configuration options.
      */
     constructor(options) {
-        super();
         // TODO placeholder node may need redesigned
         this._root = null;
         this._size = 0;
@@ -190,7 +188,7 @@ export class BinaryTree extends AbstractBinaryTree {
         else if (typeof keyOrNode === 'number') {
             needInsert = this.createNode(keyOrNode, val);
         }
-        else if (keyOrNode instanceof AbstractBinaryTreeNode) {
+        else if (keyOrNode instanceof BinaryTreeNode) {
             needInsert = keyOrNode;
         }
         else {
@@ -233,7 +231,7 @@ export class BinaryTree extends AbstractBinaryTree {
         const inserted = [];
         for (let i = 0; i < keysOrNodes.length; i++) {
             const keyOrNode = keysOrNodes[i];
-            if (keyOrNode instanceof AbstractBinaryTreeNode) {
+            if (keyOrNode instanceof BinaryTreeNode) {
                 inserted.push(this.add(keyOrNode.key, keyOrNode.val));
                 continue;
             }
@@ -755,7 +753,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - An optional parameter that represents either a node or a property name.
      * If a node is provided, the bfs algorithm will be performed starting from that node.
      * If a property name is provided, the bfs algorithm will be performed starting from the root node, accumulating the specified property.
-     * @returns An instance of the `AbstractBinaryTreeNodeProperties` class with generic type `N`.
+     * @returns An instance of the `BinaryTreeNodeProperties` class with generic type `N`.
      */
     bfs(nodeOrPropertyName = 'key') {
         this._clearResults();
@@ -777,7 +775,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * each node based on the specified pattern and property name.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. If no `nodeOrPropertyName` is provided, the default value is `'key'`.
-     * @returns an instance of the AbstractBinaryTreeNodeProperties class, which contains the accumulated properties of the binary tree nodes based on the specified pattern and node or property name.
+     * @returns an instance of the BinaryTreeNodeProperties class, which contains the accumulated properties of the binary tree nodes based on the specified pattern and node or property name.
      */
     dfs(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
@@ -814,7 +812,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * specify the traversal pattern and the property name to accumulate results by.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The name of a property of the nodes in the binary tree. This property will be used to accumulate values during the depth-first search traversal. By default, it is set to `'key'`.
-     * @returns An object of type AbstractBinaryTreeNodeProperties<N>.
+     * @returns An object of type BinaryTreeNodeProperties<N>.
      */
     dfsIterative(pattern = 'in', nodeOrPropertyName = 'key') {
         this._clearResults();
@@ -866,7 +864,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * can be either a `BinaryTreeNode` property name or the string `'key'`. If a property name is provided, the function
      * will accumulate results based on that property. If no property name is provided, the function will default to
      * accumulating results based on the 'key' property.
-     * @returns An object of type `AbstractBinaryTreeNodeProperties<N>`.
+     * @returns An object of type `BinaryTreeNodeProperties<N>`.
      */
     levelIterative(node = this.root, nodeOrPropertyName = 'key') {
         if (!node)
@@ -964,7 +962,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * The `morris` function performs an in-order, pre-order, or post-order traversal on a binary tree using the Morris traversal algorithm.
      * @param {'in' | 'pre' | 'post'} [pattern] - The traversal pattern: 'in' (in-order), 'pre' (pre-order), or 'post' (post-order).
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The property name of the nodes to retrieve or perform operations on during the traversal. It can be any valid property name of the nodes in the binary tree. If not provided, it defaults to 'key'.
-     * @returns An array of AbstractBinaryTreeNodeProperties<N> objects.
+     * @returns An array of BinaryTreeNodeProperties<N> objects.
      */
     morris(pattern = 'in', nodeOrPropertyName = 'key') {
         if (this.root === null)
@@ -1189,7 +1187,7 @@ export class BinaryTree extends AbstractBinaryTree {
      * name.
      * @param {NodeOrPropertyName} [nodeOrPropertyName] - The parameter `nodeOrPropertyName` is an optional parameter that
      * can accept either a `NodeOrPropertyName` type or be undefined.
-     * @returns The method `_getResultByPropertyName` returns an instance of `AbstractBinaryTreeNodeProperties<N>`.
+     * @returns The method `_getResultByPropertyName` returns an instance of `BinaryTreeNodeProperties<N>`.
      */
     _getResultByPropertyName(nodeOrPropertyName = 'key') {
         switch (nodeOrPropertyName) {

package/lib/data-structures/binary-tree/bst.d.ts

@@ -8,11 +8,11 @@
 import type { BinaryTreeNodeKey, BinaryTreeNodePropertyName, BSTComparator, BSTNodeNested, BSTOptions } from '../../types';
 import { CP } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
-import { IBST, IBSTNode } from '../../interfaces';
-export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> implements IBSTNode<V, FAMILY> {
+import { IBinaryTree } from '../../interfaces';
+export declare class BSTNode<V = any, FAMILY extends BSTNode<V, FAMILY> = BSTNodeNested<V>> extends BinaryTreeNode<V, FAMILY> {
     constructor(key: BinaryTreeNodeKey, val?: V);
 }
-export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
+export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBinaryTree<N> {
     /**
      * The constructor function initializes a binary search tree object with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains configuration options for the binary search tree.

package/lib/data-structures/binary-tree/index.d.ts

@@ -1,12 +1,7 @@
-export * from './abstract-binary-tree';
 export * from './binary-tree';
 export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './b-tree';
 export * from './rb-tree';
-export * from './splay-tree';
-export * from './aa-tree';
 export * from './tree-multiset';
-export * from './two-three-tree';

package/lib/data-structures/binary-tree/index.js

@@ -1,12 +1,7 @@
-export * from './abstract-binary-tree';
 export * from './binary-tree';
 export * from './bst';
 export * from './binary-indexed-tree';
 export * from './segment-tree';
 export * from './avl-tree';
-export * from './b-tree';
 export * from './rb-tree';
-export * from './splay-tree';
-export * from './aa-tree';
 export * from './tree-multiset';
-export * from './two-three-tree';

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -1,13 +1,13 @@
 import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
-import { IRBTree, IRBTreeNode } from '../../interfaces';
+import { IBinaryTree } from '../../interfaces';
 import { BST, BSTNode } from './bst';
-export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> implements IRBTreeNode<V, FAMILY> {
+export declare class RBTreeNode<V = any, FAMILY extends RBTreeNode<V, FAMILY> = RBTreeNodeNested<V>> extends BSTNode<V, FAMILY> {
     private _color;
     constructor(key: BinaryTreeNodeKey, val?: V);
     get color(): RBColor;
     set color(value: RBColor);
 }
-export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
+export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IBinaryTree<N> {
     constructor(options?: RBTreeOptions);
     createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 }

package/lib/data-structures/binary-tree/tree-multiset.d.ts

@@ -7,9 +7,9 @@
  */
 import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
 import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
-import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
+import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> implements ITreeMultisetNode<V, FAMILY> {
+export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V, FAMILY> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, FAMILY> {
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -26,7 +26,7 @@ export declare class TreeMultisetNode<V = any, FAMILY extends TreeMultisetNode<V
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode> extends AVLTree<N> implements ITreeMultiset<N> {
+export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultisetNode> extends AVLTree<N> implements IBinaryTree<N> {
     /**
      * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.

package/lib/data-structures/graph/abstract-graph.d.ts

@@ -1,5 +1,5 @@
 import type { DijkstraResult, VertexKey } from '../../types';
-import { IAbstractGraph } from '../../interfaces';
+import { IGraph } from '../../interfaces';
 export declare abstract class AbstractVertex<V = any> {
     /**
      * The function is a protected constructor that takes an key and an optional value as parameters.
@@ -46,7 +46,7 @@ export declare abstract class AbstractEdge<V = any> {
      */
     protected _setHashCode(v: string): void;
 }
-export declare abstract class AbstractGraph<V extends AbstractVertex<any> = AbstractVertex<any>, E extends AbstractEdge<any> = AbstractEdge<any>> implements IAbstractGraph<V, E> {
+export declare abstract class AbstractGraph<V extends AbstractVertex<any> = AbstractVertex<any>, E extends AbstractEdge<any> = AbstractEdge<any>> implements IGraph<V, E> {
     private _vertices;
     get vertices(): Map<VertexKey, V>;
     /**

package/lib/data-structures/graph/directed-graph.d.ts

@@ -1,6 +1,6 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexKey } from '../../types';
-import { IDirectedGraph } from '../../interfaces';
+import { IGraph } from '../../interfaces';
 export declare class DirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.
@@ -31,7 +31,7 @@ export declare class DirectedEdge<V = any> extends AbstractEdge<V> {
     get dest(): VertexKey;
     set dest(v: VertexKey);
 }
-export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
+export declare class DirectedGraph<V extends DirectedVertex<any> = DirectedVertex, E extends DirectedEdge<any> = DirectedEdge> extends AbstractGraph<V, E> implements IGraph<V, E> {
     /**
      * The constructor function initializes an instance of a class.
      */

package/lib/data-structures/graph/map-graph.d.ts

@@ -73,7 +73,7 @@ export declare class MapGraph<V extends MapVertex<V['val']> = MapVertex, E exten
      * If the weight is not provided, it can be set to a default value or left undefined.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, casted as type `E`.
+     * @returns a new instance of the `MapEdge` class, cast as type `E`.
      */
     createEdge(src: VertexKey, dest: VertexKey, weight?: number, val?: E['val']): E;
 }

package/lib/data-structures/graph/map-graph.js

@@ -97,7 +97,7 @@ export class MapGraph extends DirectedGraph {
      * If the weight is not provided, it can be set to a default value or left undefined.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the edge. It can be of any type,
      * depending on the specific implementation of the `MapEdge` class.
-     * @returns a new instance of the `MapEdge` class, casted as type `E`.
+     * @returns a new instance of the `MapEdge` class, cast as type `E`.
      */
     createEdge(src, dest, weight, val) {
         return new MapEdge(src, dest, weight, val);

package/lib/data-structures/graph/undirected-graph.d.ts

@@ -1,6 +1,6 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexKey } from '../../types';
-import { IUNDirectedGraph } from '../../interfaces';
+import { IGraph } from '../../interfaces';
 export declare class UndirectedVertex<V = any> extends AbstractVertex<V> {
     /**
      * The constructor function initializes a vertex with an optional value.
@@ -27,7 +27,7 @@ export declare class UndirectedEdge<V = number> extends AbstractEdge<V> {
     get vertices(): [VertexKey, VertexKey];
     set vertices(v: [VertexKey, VertexKey]);
 }
-export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IUNDirectedGraph<V, E> {
+export declare class UndirectedGraph<V extends UndirectedVertex<any> = UndirectedVertex, E extends UndirectedEdge<any> = UndirectedEdge> extends AbstractGraph<V, E> implements IGraph<V, E> {
     /**
      * The constructor initializes a new Map object to store edges.
      */

package/lib/data-structures/hash/index.d.ts

@@ -1,7 +1,6 @@
 export * from './hash-table';
 export * from './coordinate-map';
 export * from './coordinate-set';
-export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
 export * from './hash-map';

package/lib/data-structures/hash/index.js

@@ -1,7 +1,6 @@
 export * from './hash-table';
 export * from './coordinate-map';
 export * from './coordinate-set';
-export * from './pair';
 export * from './tree-map';
 export * from './tree-set';
 export * from './hash-map';

package/lib/data-structures/heap/heap.d.ts

@@ -4,11 +4,11 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { CompareFunction } from '../../types';
+import type { HeapComparator, HeapDFSOrderPattern } from '../../types';
 export declare class Heap<E> {
     protected nodes: E[];
     private readonly comparator;
-    constructor(comparator: CompareFunction<E>);
+    constructor(comparator: HeapComparator<E>);
     /**
      * Insert an element into the heap and maintain the heap properties.
      * @param value - The element to be inserted.
@@ -72,7 +72,7 @@ export declare class Heap<E> {
      * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
      * @returns An array containing elements traversed in the specified order.
      */
-    dfs(order: 'in' | 'pre' | 'post'): E[];
+    dfs(order: HeapDFSOrderPattern): E[];
     /**
      * Convert the heap to an array.
      * @returns An array containing the elements of the heap.
@@ -95,5 +95,5 @@ export declare class Heap<E> {
      * @param comparator - Comparison function.
      * @returns A new Heap instance.
      */
-    static heapify<E>(nodes: E[], comparator: CompareFunction<E>): Heap<E>;
+    static heapify<E>(nodes: E[], comparator: HeapComparator<E>): Heap<E>;
 }

package/lib/data-structures/heap/max-heap.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { Heap } from './heap';
-import type { CompareFunction } from '../../types';
+import type { HeapComparator } from '../../types';
 export declare class MaxHeap<E = any> extends Heap<E> {
-    constructor(comparator?: CompareFunction<E>);
+    constructor(comparator?: HeapComparator<E>);
 }

package/lib/data-structures/heap/min-heap.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { Heap } from './heap';
-import type { CompareFunction } from '../../types';
+import type { HeapComparator } from '../../types';
 export declare class MinHeap<E = any> extends Heap<E> {
-    constructor(comparator?: CompareFunction<E>);
+    constructor(comparator?: HeapComparator<E>);
 }

package/lib/data-structures/priority-queue/max-priority-queue.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { CompareFunction } from '../../types';
+import type { HeapComparator } from '../../types';
 export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: CompareFunction<E>);
+    constructor(compare?: HeapComparator<E>);
 }

package/lib/data-structures/priority-queue/min-priority-queue.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { PriorityQueue } from './priority-queue';
-import type { CompareFunction } from '../../types';
+import type { HeapComparator } from '../../types';
 export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
-    constructor(compare?: CompareFunction<E>);
+    constructor(compare?: HeapComparator<E>);
 }

package/lib/data-structures/priority-queue/priority-queue.d.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import { Heap } from '../heap';
-import { CompareFunction } from '../../types';
+import { HeapComparator } from '../../types';
 export declare class PriorityQueue<E> extends Heap<E> {
-    constructor(comparator: CompareFunction<E>);
+    constructor(comparator: HeapComparator<E>);
 }

package/lib/interfaces/binary-tree.d.ts

@@ -1,6 +1,7 @@
 import { BinaryTreeNode } from '../data-structures';
-import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
-export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
-}
-export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
+import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> {
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
+    add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val']): N | null | undefined;
+    remove(nodeOrKey: N | BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];
 }

package/lib/interfaces/{abstract-graph.d.ts → graph.d.ts}

@@ -1,5 +1,5 @@
 import { VertexKey } from '../types';
-export interface IAbstractGraph<V, E> {
+export interface IGraph<V, E> {
     createVertex(key: VertexKey, val?: V): V;
     createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
 }

package/lib/interfaces/index.d.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/lib/interfaces/index.js

@@ -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/lib/types/data-structures/abstract-graph.d.ts

@@ -1,5 +1,4 @@
 export type VertexKey = string | number;
-export type EdgeKey = string;
 export type DijkstraResult<V> = {
     distMap: Map<V, number>;
     distPaths?: Map<V, V[]>;

package/lib/types/data-structures/binary-tree.d.ts

@@ -1,6 +1,34 @@
 import { BinaryTreeNode } from '../../data-structures/binary-tree';
-import { AbstractBinaryTreeOptions, LoopType } from './abstract-binary-tree';
+/**
+ * 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 declare enum LoopType {
+    ITERATIVE = "ITERATIVE",
+    RECURSIVE = "RECURSIVE"
+}
+export declare enum FamilyPosition {
+    ROOT = "ROOT",
+    LEFT = "LEFT",
+    RIGHT = "RIGHT",
+    ROOT_LEFT = "ROOT_LEFT",
+    ROOT_RIGHT = "ROOT_RIGHT",
+    ISOLATED = "ISOLATED",
+    MAL_NODE = "MAL_NODE"
+}
+export type BinaryTreeNodePropertyName = 'key' | 'val';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeKey = number;
+export type BinaryTreeNodeProperty<N extends BinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
+export type BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type BinaryTreeNodeProperties<N extends BinaryTreeNode<N['val'], N>> = BinaryTreeNodeProperty<N>[];
 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 = AbstractBinaryTreeOptions & {
+export type BinaryTreeOptions = {
     loopType?: LoopType;
 };

package/lib/types/data-structures/binary-tree.js

@@ -1 +1,21 @@
-export {};
+/**
+ * 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 var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType || (LoopType = {}));
+export var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition["ROOT"] = "ROOT";
+    FamilyPosition["LEFT"] = "LEFT";
+    FamilyPosition["RIGHT"] = "RIGHT";
+    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
+    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
+    FamilyPosition["ISOLATED"] = "ISOLATED";
+    FamilyPosition["MAL_NODE"] = "MAL_NODE";
+})(FamilyPosition || (FamilyPosition = {}));

package/lib/types/data-structures/bst.d.ts

@@ -1,6 +1,5 @@
 import { BSTNode } from '../../data-structures/binary-tree';
-import type { BinaryTreeOptions } from './binary-tree';
-import { BinaryTreeNodeKey } from './abstract-binary-tree';
+import type { BinaryTreeNodeKey, BinaryTreeOptions } from './binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeKey, b: BinaryTreeNodeKey) => number;
 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 & {

package/lib/types/data-structures/heap.d.ts

@@ -1 +1,2 @@
-export type CompareFunction<T> = (a: T, b: T) => number;
+export type HeapComparator<T> = (a: T, b: T) => number;
+export type HeapDFSOrderPattern = 'pre' | 'in' | 'post';

package/lib/types/data-structures/index.d.ts

@@ -5,10 +5,8 @@ export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-graph';
 export * from './map-graph';
-export * from './abstract-binary-tree';
 export * from './rb-tree';
 export * from './directed-graph';
-export * from './priority-queue';
 export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';

package/lib/types/data-structures/index.js

@@ -5,10 +5,8 @@ export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-graph';
 export * from './map-graph';
-export * from './abstract-binary-tree';
 export * from './rb-tree';
 export * from './directed-graph';
-export * from './priority-queue';
 export * from './heap';
 export * from './singly-linked-list';
 export * from './doubly-linked-list';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.1",
+  "version": "1.36.3",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -54,17 +54,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.36.0",
+    "avl-tree-typed": "^1.36.2",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.36.0",
-    "bst-typed": "^1.36.0",
+    "binary-tree-typed": "^1.36.2",
+    "bst-typed": "^1.36.2",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.35.1",
+    "heap-typed": "^1.36.2",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",

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

@@ -7,12 +7,12 @@
  */
 import {BST, BSTNode} from './bst';
 import type {AVLTreeNodeNested, AVLTreeOptions, BinaryTreeDeletedResult, BinaryTreeNodeKey} from '../../types';
-import {IAVLTree, IAVLTreeNode} from '../../interfaces';
+import {IBinaryTree} from '../../interfaces';
 
-export class AVLTreeNode<V = any, FAMILY extends AVLTreeNode<V, FAMILY> = AVLTreeNodeNested<V>>
-  extends BSTNode<V, FAMILY>
-  implements IAVLTreeNode<V, FAMILY>
-{
+export class AVLTreeNode<V = any, FAMILY extends AVLTreeNode<V, FAMILY> = AVLTreeNodeNested<V>> extends BSTNode<
+  V,
+  FAMILY
+> {
   height: number;
 
   constructor(key: BinaryTreeNodeKey, val?: V) {
@@ -21,7 +21,7 @@ export class AVLTreeNode<V = any, FAMILY extends AVLTreeNode<V, FAMILY> = AVLTre
   }
 }
 
-export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IAVLTree<N> {
+export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends BST<N> implements IBinaryTree<N> {
   /**
    * This is a constructor function for an AVL tree data structure in TypeScript.
    * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be passed to the