data-structure-typed 1.35.0 → 1.36.0

package/dist/interfaces/abstract-graph.d.ts

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

package/dist/interfaces/avl-tree.d.ts

@@ -0,0 +1,7 @@
+import { AVLTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+    height: number;
+}
+export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
+}

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

@@ -0,0 +1,6 @@
+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> {
+}

package/dist/interfaces/bst.d.ts

@@ -0,0 +1,6 @@
+import { BSTNode } from '../data-structures';
+import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
+}

package/dist/interfaces/directed-graph.d.ts

@@ -0,0 +1,3 @@
+import { IAbstractGraph } from './abstract-graph';
+export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+}

package/dist/interfaces/doubly-linked-list.d.ts

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

package/dist/interfaces/heap.d.ts

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

package/dist/interfaces/index.d.ts

@@ -0,0 +1,15 @@
+export * from './abstract-binary-tree';
+export * from './abstract-graph';
+export * from './avl-tree';
+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/dist/interfaces/navigator.d.ts

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

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

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

package/dist/interfaces/rb-tree.d.ts

@@ -0,0 +1,6 @@
+import { RBTreeNode } from '../data-structures';
+import { IBST, IBSTNode } from './bst';
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
+export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
+}

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

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

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

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

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

@@ -0,0 +1,6 @@
+import { TreeMultisetNode } from '../data-structures';
+import { IAVLTree, IAVLTreeNode } from './avl-tree';
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IAVLTreeNode<T, NEIGHBOR> {
+}
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+}

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

@@ -0,0 +1,3 @@
+import { IAbstractGraph } from './abstract-graph';
+export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
+}

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

@@ -0,0 +1,34 @@
+import { AbstractBinaryTreeNode } 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 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 BinaryTreeDeletedResult<N> = {
+    deleted: N | null | undefined;
+    needBalanced: N | null;
+};
+export type AbstractBinaryTreeNodeProperty<N extends AbstractBinaryTreeNode<N['val'], N>> = N['val'] | N | number | BinaryTreeNodeKey;
+export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N['val'], N>> = AbstractBinaryTreeNodeProperty<N>[];
+export type AbstractBinaryTreeNodeNested<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;
+};

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

@@ -1,6 +1,12 @@
 "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";

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

@@ -1 +1 @@
-{"version":3,"file":"abstract-binary-tree.js","sourceRoot":"","sources":["../../../src/types/data-structures/abstract-binary-tree.ts"],"names":[],"mappings":";;;AASA,IAAY,QAGX;AAHD,WAAY,QAAQ;IAClB,mCAAuB,CAAA;IACvB,mCAAuB,CAAA;AACzB,CAAC,EAHW,QAAQ,wBAAR,QAAQ,QAGnB;AAED,IAAY,cAQX;AARD,WAAY,cAAc;IACxB,+BAAa,CAAA;IACb,+BAAa,CAAA;IACb,iCAAe,CAAA;IACf,yCAAuB,CAAA;IACvB,2CAAyB,CAAA;IACzB,uCAAqB,CAAA;IACrB,uCAAqB,CAAA;AACvB,CAAC,EARW,cAAc,8BAAd,cAAc,QAQzB"}
+{"version":3,"file":"abstract-binary-tree.js","sourceRoot":"","sources":["../../../src/types/data-structures/abstract-binary-tree.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AAEH,IAAY,QAGX;AAHD,WAAY,QAAQ;IAClB,mCAAuB,CAAA;IACvB,mCAAuB,CAAA;AACzB,CAAC,EAHW,QAAQ,wBAAR,QAAQ,QAGnB;AAED,IAAY,cAQX;AARD,WAAY,cAAc;IACxB,+BAAa,CAAA;IACb,+BAAa,CAAA;IACb,iCAAe,CAAA;IACf,yCAAuB,CAAA;IACvB,2CAAyB,CAAA;IACzB,uCAAqB,CAAA;IACrB,uCAAqB,CAAA;AACvB,CAAC,EARW,cAAc,8BAAd,cAAc,QAQzB"}

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

@@ -0,0 +1,11 @@
+export type VertexKey = string | number;
+export type EdgeKey = string;
+export type DijkstraResult<V> = {
+    distMap: Map<V, number>;
+    distPaths?: Map<V, V[]>;
+    preMap: Map<V, V | null>;
+    seen: Set<V>;
+    paths: V[][];
+    minDist: number;
+    minPath: V[];
+} | null;

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

@@ -0,0 +1,4 @@
+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/dist/types/data-structures/binary-tree.d.ts

@@ -0,0 +1,4 @@
+import { BinaryTreeNode } from '../../data-structures/binary-tree';
+import { AbstractBinaryTreeOptions } from './abstract-binary-tree';
+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 & {};

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

@@ -0,0 +1,13 @@
+import { BSTNode } from '../../data-structures/binary-tree';
+import type { BinaryTreeOptions } from './binary-tree';
+import { BinaryTreeNodeKey } from './abstract-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 & {
+    comparator?: BSTComparator;
+};
+export declare enum CP {
+    lt = "lt",
+    eq = "eq",
+    gt = "gt"
+}

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

@@ -0,0 +1,6 @@
+export type TopologicalStatus = 0 | 1 | 2;
+export declare enum TopologicalProperty {
+    VAL = "VAL",
+    NODE = "NODE",
+    ID = "ID"
+}

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

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

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

@@ -0,0 +1 @@
+export type HashFunction<K> = (key: K) => number;

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

@@ -0,0 +1 @@
+export type CompareFunction<T> = (a: T, b: T) => number;

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

@@ -0,0 +1,16 @@
+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 './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';
+export * from './navigator';
+export * from './hash';

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

@@ -0,0 +1 @@
+export type MapGraphCoordinate = [number, number];

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

@@ -0,0 +1,14 @@
+export type Direction = 'up' | 'right' | 'down' | 'left';
+export type Turning = {
+    [key in Direction]: Direction;
+};
+export type NavigatorParams<T = any> = {
+    matrix: T[][];
+    turning: Turning;
+    onMove: (cur: [number, number]) => void;
+    init: {
+        cur: [number, number];
+        charDir: Direction;
+        VISITED: T;
+    };
+};

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

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

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

@@ -0,0 +1,8 @@
+import { BinaryTreeOptions } from './binary-tree';
+import { RBTreeNode } from '../../data-structures/binary-tree';
+export declare enum RBColor {
+    RED = "RED",
+    BLACK = "BLACK"
+}
+export type RBTreeNodeNested<T> = RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, RBTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type RBTreeOptions = BinaryTreeOptions & {};

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

@@ -0,0 +1 @@
+export type SegmentTreeNodeVal = number;

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

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

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

@@ -0,0 +1,4 @@
+import { TreeMultisetNode } from '../../data-structures/binary-tree';
+import { AVLTreeOptions } from './avl-tree';
+export type TreeMultisetNodeNested<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<AVLTreeOptions, 'isMergeDuplicatedNodeByKey'> & {};

package/dist/types/helpers.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './data-structures';
+export * from './helpers';
+export * from './utils';

package/dist/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './validate-type';

package/dist/types/utils/utils.d.ts

@@ -0,0 +1,7 @@
+export type ToThunkFn = () => ReturnType<TrlFn>;
+export type Thunk = () => ReturnType<ToThunkFn> & {
+    __THUNK__: symbol;
+};
+export type TrlFn = (...args: any[]) => any;
+export type TrlAsyncFn = (...args: any[]) => any;
+export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/types/utils/validate-type.d.ts

@@ -0,0 +1,19 @@
+export type KeyValueObject = {
+    [key: string]: any;
+};
+export type KeyValueObjectWithKey = {
+    [key: string]: any;
+    key: string | number | symbol;
+};
+export type NonNumberNonObjectButDefined = string | boolean | symbol | null;
+export type ObjectWithoutKey = Omit<KeyValueObject, 'key'>;
+export type ObjectWithNonNumberKey = {
+    [key: string]: any;
+    key: string | boolean | symbol | null | object | undefined;
+};
+export type ObjectWithNumberKey = {
+    [key: string]: any;
+    key: number;
+};
+export type RestrictValByKey = NonNumberNonObjectButDefined | ObjectWithoutKey | ObjectWithNonNumberKey | ObjectWithNumberKey;
+export type DummyAny = string | number | boolean | null | undefined | object | symbol | void | ((...args: []) => any) | never;

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';

package/dist/utils/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { Thunk, ToThunkFn, TrlAsyncFn, TrlFn } from '../types';
+export declare const uuidV4: () => string;
+export declare const arrayRemove: <T>(array: T[], predicate: (item: T, index: number, array: T[]) => boolean) => T[];
+export declare const THUNK_SYMBOL: unique symbol;
+export declare const isThunk: (fnOrValue: any) => boolean;
+export declare const toThunk: (fn: ToThunkFn) => Thunk;
+export declare const trampoline: (fn: TrlFn) => ((...args: [...Parameters<TrlFn>]) => any) & {
+    cont: (...args: [...Parameters<TrlFn>]) => Thunk;
+};
+export declare const trampolineAsync: (fn: TrlAsyncFn) => ((...args: [...Parameters<TrlAsyncFn>]) => Promise<any>) & {
+    cont: (...args: [...Parameters<TrlAsyncFn>]) => Thunk;
+};

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

@@ -1,8 +1,8 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
 import { arrayRemove, uuidV4 } from '../../utils';
@@ -523,9 +523,7 @@ export class AbstractGraph {
             if (vertexOrKey instanceof AbstractVertex)
                 distMap.set(vertexOrKey, Infinity);
         }
-        const heap = new PriorityQueue({
-            comparator: (a, b) => a.key - b.key
-        });
+        const heap = new PriorityQueue((a, b) => a.key - b.key);
         heap.add({ key: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);

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

@@ -1,83 +1,100 @@
 /**
  * data-structure-typed
  *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from '../priority-queue';
-import type { HeapOptions } from '../../types';
-export declare class HeapItem<V = any> {
-    /**
-     * The constructor function initializes an instance of a class with a priority and a value.
-     * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
-     * optional and has a default value of `NaN`.
-     * @param {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
-     * `V` or `null`.
-     */
-    constructor(priority?: number, val?: V | null);
-    private _priority;
-    get priority(): number;
-    set priority(value: number);
-    private _val;
-    get val(): V | null;
-    set val(value: V | null);
-}
-export declare abstract class Heap<V = any> {
+import type { CompareFunction } from '../../types';
+export declare class Heap<T> {
+    private nodes;
+    private readonly comparator;
+    constructor(comparator: CompareFunction<T>);
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param value - The element to be inserted.
+     */
+    add(value: T): Heap<T>;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or null if the heap is empty.
+     */
+    poll(): T | null;
+    /**
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
+     */
+    protected bubbleUp(index: number): void;
     /**
-     * The function is a constructor for a class that initializes a priority callback function based on the
-     * options provided.
-     * @param [options] - An optional object that contains configuration options for the Heap.
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
      */
-    protected constructor(options?: HeapOptions<V>);
-    protected abstract _pq: PriorityQueue<HeapItem<V>>;
-    get pq(): PriorityQueue<HeapItem<V>>;
-    protected _priorityExtractor: (val: V) => number;
-    get priorityExtractor(): (val: V) => number;
+    protected sinkDown(index: number): void;
     /**
-     * The function returns the size of a priority queue.
-     * @returns The size of the priority queue.
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
+    /**
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or null if the heap is empty.
+     */
+    peek(): T | null;
+    /**
+     * Get the size (number of elements) of the heap.
      */
     get size(): number;
     /**
-     * The function checks if a priority queue is empty.
-     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or null if the heap is empty.
      */
-    isEmpty(): boolean;
-    peek(isItem?: undefined): V | undefined;
-    peek(isItem: false): V | undefined;
-    peek(isItem: true): HeapItem<V> | null;
-    peekLast(isItem?: undefined): V | undefined;
-    peekLast(isItem: false): V | undefined;
-    peekLast(isItem: true): HeapItem<V> | null;
-    /**
-     * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {V} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
-     * type.
-     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
-     * the value of `val`. If the `val` parameter is not a number, then the
-     * @returns The `add` method returns the instance of the `Heap` class.
-     * @throws {Error} if priority is not a valid number
-     */
-    add(priority: number, val?: V): Heap<V>;
-    poll(isItem?: undefined): V | undefined;
-    poll(isItem: false): V | undefined;
-    poll(isItem: true): HeapItem<V> | null;
-    /**
-     * The function checks if a given node or value exists in the priority queue.
-     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
-     * @returns a boolean value.
-     */
-    has(node: V | HeapItem<V>): boolean;
-    toArray(isItem?: undefined): (V | undefined)[];
-    toArray(isItem: false): (V | undefined)[];
-    toArray(isItem: true): (HeapItem<V> | null)[];
-    sort(isItem?: undefined): (V | undefined)[];
-    sort(isItem: false): (V | undefined)[];
-    sort(isItem: true): (HeapItem<V> | null)[];
-    /**
-     * The clear function clears the priority queue.
+    leaf(): T | null;
+    /**
+     * Check if the heap is empty.
+     * @returns True if the heap is empty, otherwise false.
      */
+    isEmpty(): boolean;
     clear(): void;
+    refill(nodes: T[]): void;
+    /**
+     * Use a comparison function to check whether a binary heap contains a specific element.
+     * @param value - the element to check.
+     * @returns Returns true if the specified element is contained; otherwise, returns false.
+     */
+    has(value: T): boolean;
+    /**
+     * Use a comparison function to find the index of an element in the heap.
+     * @param value - the element to find.
+     * @param index - the index currently being searched.
+     * @returns The index of the element, or -1 if not found.
+     */
+    private findIndex;
+    /**
+     * Depth-first search (DFS) method, different traversal orders can be selected。
+     * @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'): T[];
+    /**
+     * Convert the heap to an array.
+     * @returns An array containing the elements of the heap.
+     */
+    toArray(): T[];
+    getNodes(): T[];
+    /**
+     * Clone the heap, creating a new heap with the same elements.
+     * @returns A new Heap instance containing the same elements.
+     */
+    clone(): Heap<T>;
+    /**
+     * Sort the elements in the heap and return them as an array.
+     * @returns An array containing the elements sorted in ascending order.
+     */
+    sort(): T[];
+    /**
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @param nodes
+     * @param comparator - Comparison function.
+     * @returns A new Heap instance.
+     */
+    static heapify<T>(nodes: T[], comparator: CompareFunction<T>): Heap<T>;
 }