data-structure-typed 1.18.0 → 1.18.6

package/dist/data-structures/interfaces/index.d.ts

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

package/dist/data-structures/interfaces/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__exportStar(require("./avl-tree"), exports);
+__exportStar(require("./segment-tree"), exports);
+__exportStar(require("./tree-multiset"), exports);
+__exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./directed-graph"), exports);
+__exportStar(require("./undirected-graph"), exports);
+__exportStar(require("./priority-queue"), exports);
+__exportStar(require("./heap"), exports);
+__exportStar(require("./singly-linked-list"), exports);
+__exportStar(require("./doubly-linked-list"), exports);
+__exportStar(require("./navigator"), exports);

package/dist/data-structures/interfaces/navigator.d.ts

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

package/dist/data-structures/interfaces/navigator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/priority-queue.d.ts

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

package/dist/data-structures/interfaces/priority-queue.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/segment-tree.d.ts

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

package/dist/data-structures/interfaces/segment-tree.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/singly-linked-list.d.ts

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

package/dist/data-structures/interfaces/singly-linked-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/tree-multiset.d.ts

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

package/dist/data-structures/interfaces/tree-multiset.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/interfaces/undirected-graph.d.ts

@@ -0,0 +1,2 @@
+export interface IUNDirectedGraph<V, E> {
+}

package/dist/data-structures/interfaces/undirected-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -22,7 +22,7 @@ export declare class DoublyLinkedListNode<T = number> {
     get prev(): DoublyLinkedListNode<T> | null;
     set prev(value: DoublyLinkedListNode<T> | null);
 }
-export declare class DoublyLinkedList<T> {
+export declare class DoublyLinkedList<T = number> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -19,7 +19,7 @@ export declare class SinglyLinkedListNode<T = number> {
     get next(): SinglyLinkedListNode<T> | null;
     set next(value: SinglyLinkedListNode<T> | null);
 }
-export declare class SinglyLinkedList<T> {
+export declare class SinglyLinkedList<T = number> {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */

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

@@ -15,7 +15,6 @@ export declare class PriorityQueue<T = number> {
     constructor(options: PriorityQueueOptions<T>);
     protected _nodes: T[];
     get nodes(): T[];
-    protected set nodes(value: T[]);
     get size(): number;
     /**
      * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
@@ -112,6 +111,7 @@ export declare class PriorityQueue<T = number> {
      * @returns an array of type `(T | null)[]`.
      */
     DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
+    protected _setNodes(value: T[]): void;
     protected readonly _comparator: PriorityQueueComparator<T>;
     /**
      * The function compares two numbers using a custom comparator function.

package/dist/data-structures/priority-queue/priority-queue.js

@@ -61,9 +61,6 @@ var PriorityQueue = /** @class */ (function () {
         get: function () {
             return this._nodes;
         },
-        set: function (value) {
-            this._nodes = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -167,7 +164,7 @@ var PriorityQueue = /** @class */ (function () {
      * The clear function clears the nodes array.
      */
     PriorityQueue.prototype.clear = function () {
-        this.nodes = [];
+        this._setNodes([]);
     };
     /**
      * The toArray function returns an array containing all the elements in the nodes property.
@@ -256,6 +253,9 @@ var PriorityQueue = /** @class */ (function () {
         this._isValidIndex(0) && traverse(0);
         return visitedNode;
     };
+    PriorityQueue.prototype._setNodes = function (value) {
+        this._nodes = value;
+    };
     /**
      * The function compares two numbers using a custom comparator function.
      * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.

package/dist/data-structures/queue/deque.d.ts

@@ -8,15 +8,12 @@
 import { DoublyLinkedList } from '../linked-list';
 export declare class Deque<T> extends DoublyLinkedList<T> {
 }
-export declare class ObjectDeque<T> {
+export declare class ObjectDeque<T = number> {
     constructor(capacity?: number);
     private _nodes;
     get nodes(): {
         [p: number]: T;
     };
-    protected set nodes(value: {
-        [p: number]: T;
-    });
     private _capacity;
     get capacity(): number;
     set capacity(value: number);
@@ -28,7 +25,6 @@ export declare class ObjectDeque<T> {
     set last(value: number);
     private _size;
     get size(): number;
-    protected set size(value: number);
     addFirst(value: T): void;
     addLast(value: T): void;
     pollFirst(): T | undefined;
@@ -37,6 +33,10 @@ export declare class ObjectDeque<T> {
     peekLast(): T | undefined;
     get(index: number): NonNullable<T> | null;
     isEmpty(): boolean;
+    protected _seNodes(value: {
+        [p: number]: T;
+    }): void;
+    protected _setSize(value: number): void;
 }
 export declare class ArrayDeque<T> {
     protected _nodes: T[];

package/dist/data-structures/queue/deque.js

@@ -51,9 +51,6 @@ var ObjectDeque = /** @class */ (function () {
         get: function () {
             return this._nodes;
         },
-        set: function (value) {
-            this._nodes = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -91,9 +88,6 @@ var ObjectDeque = /** @class */ (function () {
         get: function () {
             return this._size;
         },
-        set: function (value) {
-            this._size = value;
-        },
         enumerable: false,
         configurable: true
     });
@@ -153,6 +147,12 @@ var ObjectDeque = /** @class */ (function () {
     ObjectDeque.prototype.isEmpty = function () {
         return this._size <= 0;
     };
+    ObjectDeque.prototype._seNodes = function (value) {
+        this._nodes = value;
+    };
+    ObjectDeque.prototype._setSize = function (value) {
+        this._size = value;
+    };
     return ObjectDeque;
 }());
 exports.ObjectDeque = ObjectDeque;

package/dist/data-structures/queue/queue.d.ts

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Queue<T> {
+export declare class Queue<T = number> {
     protected _nodes: T[];
     protected _offset: number;
     /**

package/dist/data-structures/stack/stack.d.ts

@@ -3,7 +3,7 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-export declare class Stack<T> {
+export declare class Stack<T = number> {
     protected _elements: T[];
     /**
      * The constructor initializes an array of elements, which can be provided as an optional parameter.

package/dist/data-structures/types/abstract-binary-tree.d.ts

@@ -0,0 +1,32 @@
+import { AbstractBinaryTreeNode } from '../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 = 0,
+    LEFT = 1,
+    RIGHT = 2
+}
+export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
+export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
+export type DFSOrderPattern = 'in' | 'pre' | 'post';
+export type BinaryTreeNodeId = number;
+export type BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type AbstractResultByProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeId;
+export type AbstractResultsByProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractResultByProperty<N>[];
+export type AbstractRecursiveBinaryTreeNode<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AbstractBinaryTreeOptions = {
+    loopType?: LoopType;
+    autoIncrementId?: boolean;
+    isDuplicatedVal?: boolean;
+};

package/dist/data-structures/types/abstract-binary-tree.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FamilyPosition = exports.LoopType = void 0;
+/**
+ * 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).
+ */
+var LoopType;
+(function (LoopType) {
+    LoopType["ITERATIVE"] = "ITERATIVE";
+    LoopType["RECURSIVE"] = "RECURSIVE";
+})(LoopType || (exports.LoopType = LoopType = {}));
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
+var FamilyPosition;
+(function (FamilyPosition) {
+    FamilyPosition[FamilyPosition["ROOT"] = 0] = "ROOT";
+    FamilyPosition[FamilyPosition["LEFT"] = 1] = "LEFT";
+    FamilyPosition[FamilyPosition["RIGHT"] = 2] = "RIGHT";
+})(FamilyPosition || (exports.FamilyPosition = FamilyPosition = {}));

package/dist/data-structures/types/abstract-graph.d.ts

@@ -1,4 +1,5 @@
 export type VertexId = string | number;
+export type EdgeId = string;
 export type DijkstraResult<V> = {
     distMap: Map<V, number>;
     preMap: Map<V, V | null>;
@@ -7,23 +8,3 @@ export type DijkstraResult<V> = {
     minDist: number;
     minPath: V[];
 } | null;
-export interface IGraph<V, E> {
-    hasVertex(vertexOrId: V | VertexId): boolean;
-    getVertex(vertexOrId: VertexId | V): V | null;
-    getVertexId(vertexOrId: V | VertexId): VertexId;
-    vertexSet(): Map<VertexId, V>;
-    addVertex(v: V): boolean;
-    removeVertex(vertexOrId: V | VertexId): boolean;
-    removeAllVertices(vertices: V[] | VertexId[]): boolean;
-    degreeOf(vertexOrId: V | VertexId): number;
-    edgesOf(vertexOrId: V | VertexId): E[];
-    hasEdge(src: V | VertexId, dest: V | VertexId): boolean;
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    edgeSet(): E[];
-    addEdge(edge: E): boolean;
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-    removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrId: V | VertexId, destOrId: V | VertexId, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexId, v2: V | VertexId, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrId: V | VertexId): V[];
-}

package/dist/data-structures/types/avl-tree.d.ts

@@ -1,5 +1,4 @@
 import { AVLTreeNode } from '../binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
+import { BSTOptions } from './bst';
+export type RecursiveAVLTreeNode<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/dist/data-structures/types/binary-tree.d.ts

@@ -1,11 +1,4 @@
 import { BinaryTreeNode } from '../binary-tree';
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = {
-    deleted: BinaryTreeNode<T> | null | undefined;
-    needBalanced: BinaryTreeNode<T> | null;
-};
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
+import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
+export type RecursiveBinaryTreeNode<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 & {};

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

@@ -1,7 +1,13 @@
 import { BSTNode } from '../binary-tree';
-import type { BinaryTreeNodeId } from './binary-tree';
+import type { BinaryTreeOptions } from './binary-tree';
+import { BinaryTreeNodeId } from './abstract-binary-tree';
 export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
+export type RecursiveBSTNode<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, BSTNode<T, BSTNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type BSTOptions = BinaryTreeOptions & {
+    comparator?: BSTComparator;
 };
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

package/dist/data-structures/types/bst.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CP = void 0;
+var CP;
+(function (CP) {
+    CP["lt"] = "lt";
+    CP["eq"] = "eq";
+    CP["gt"] = "gt";
+})(CP || (exports.CP = CP = {}));

package/dist/data-structures/types/directed-graph.d.ts

@@ -1,10 +1,6 @@
-import { VertexId } from './abstract-graph';
-export interface IDirectedGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-    outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrId: V | VertexId): number;
-    outDegreeOf(vertexOrId: V | VertexId): number;
-    getEdgeSrc(e: E): V | null;
-    getEdgeDest(e: E): V | null;
-}
 export type TopologicalStatus = 0 | 1 | 2;
+export declare enum TopologicalProperty {
+    VAL = "VAL",
+    NODE = "NODE",
+    ID = "ID"
+}

package/dist/data-structures/types/directed-graph.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopologicalProperty = void 0;
+var TopologicalProperty;
+(function (TopologicalProperty) {
+    TopologicalProperty["VAL"] = "VAL";
+    TopologicalProperty["NODE"] = "NODE";
+    TopologicalProperty["ID"] = "ID";
+})(TopologicalProperty || (exports.TopologicalProperty = TopologicalProperty = {}));

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

@@ -1,3 +1,3 @@
-export interface HeapOptions<T> {
+export type HeapOptions<T> = {
     priority?: (element: T) => number;
-}
+};

package/dist/data-structures/types/helpers.d.ts

@@ -0,0 +1,8 @@
+export type IdObject = {
+    id: number;
+} & {
+    [key: string]: any;
+};
+export type KeyValObject = {
+    [key: string]: any;
+};

package/dist/data-structures/types/helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -4,10 +4,12 @@ export * from './avl-tree';
 export * from './segment-tree';
 export * from './tree-multiset';
 export * from './abstract-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';
 export * from './navigator';
-export * from '../../utils/types/utils';
+export * from './helpers';

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

@@ -20,10 +20,12 @@ __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
 __exportStar(require("./tree-multiset"), exports);
 __exportStar(require("./abstract-graph"), exports);
+__exportStar(require("./abstract-binary-tree"), exports);
+__exportStar(require("./rb-tree"), exports);
 __exportStar(require("./directed-graph"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./singly-linked-list"), exports);
 __exportStar(require("./doubly-linked-list"), exports);
 __exportStar(require("./navigator"), exports);
-__exportStar(require("../../utils/types/utils"), exports);
+__exportStar(require("./helpers"), exports);

package/dist/data-structures/types/navigator.d.ts

@@ -2,7 +2,7 @@ export type Direction = 'up' | 'right' | 'down' | 'left';
 export type Turning = {
     [key in Direction]: Direction;
 };
-export interface NavigatorParams<T> {
+export type NavigatorParams<T> = {
     matrix: T[][];
     turning: Turning;
     onMove: (cur: [number, number]) => void;
@@ -11,4 +11,4 @@ export interface NavigatorParams<T> {
         charDir: Direction;
         VISITED: T;
     };
-}
+};

package/dist/data-structures/types/priority-queue.d.ts

@@ -1,7 +1,7 @@
 export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-export interface PriorityQueueOptions<T> {
+export type PriorityQueueOptions<T> = {
     nodes?: T[];
     isFix?: boolean;
     comparator: PriorityQueueComparator<T>;
-}
+};
 export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';

package/dist/data-structures/types/rb-tree.d.ts

@@ -0,0 +1,6 @@
+import { BinaryTreeOptions } from './binary-tree';
+export declare enum RBColor {
+    RED = "RED",
+    BLACK = "BLACK"
+}
+export type RBTreeOptions = BinaryTreeOptions & {};

package/dist/data-structures/types/rb-tree.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBColor = void 0;
+var RBColor;
+(function (RBColor) {
+    RBColor["RED"] = "RED";
+    RBColor["BLACK"] = "BLACK";
+})(RBColor || (exports.RBColor = RBColor = {}));

package/dist/data-structures/types/tree-multiset.d.ts

@@ -1,5 +1,6 @@
-import { BSTNode } from '../binary-tree';
-export type TreeMultiSetDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
+import { BSTOptions } from './bst';
+import { TreeMultiSetNode } from '../binary-tree';
+export type RecursiveTreeMultiSetNode<T> = TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, TreeMultiSetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiSetOptions = Omit<BSTOptions, 'isDuplicatedVal'> & {
+    isDuplicatedVal: true;
 };