data-structure-typed 0.8.17 → 0.9.16

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

@@ -1,14 +1,5 @@
-import {
-    BinaryTree,
-    BinaryTreeNode,
-    BinaryTreeNodeId,
-    BinaryTreeNodePropertyName,
-    FamilyPosition,
-    LoopType,
-} from './binary-tree';
-
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };
+import type {BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult} from '../types';
+import {BinaryTree, BinaryTreeNode, FamilyPosition, LoopType,} from './binary-tree';
 
 export enum CP {lt = -1, eq = 0, gt = 1}
 
@@ -19,15 +10,6 @@ export class BSTNode<T> extends BinaryTreeNode<T> {
 }
 
 export class BST<T> extends BinaryTree<T> {
-    protected _comparator: BSTComparator = (a, b) => a - b;
-
-    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP {
-        const compared = this._comparator(a, b);
-        if (compared > 0) return CP.gt;
-        else if (compared < 0) return CP.lt;
-        else return CP.eq;
-    }
-
     constructor(options?: {
         comparator?: BSTComparator,
         loopType?: LoopType
@@ -373,8 +355,8 @@ export class BST<T> extends BinaryTree<T> {
             _height(this.root);
         } else {
             const stack: BSTNode<T>[] = [];
-            let node: BSTNode<T> | null | undefined = this.root, last: BSTNode<T> | null = null,
-                depths: Map<BSTNode<T>, number> = new Map();
+            let node: BSTNode<T> | null | undefined = this.root, last: BSTNode<T> | null = null;
+            const depths: Map<BSTNode<T>, number> = new Map();
 
             while (stack.length > 0 || node) {
                 if (node) {
@@ -385,8 +367,8 @@ export class BST<T> extends BinaryTree<T> {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let left = node.left ? depths.get(node.left) ?? -1 : -1;
-                            let right = node.right ? depths.get(node.right) ?? -1 : -1;
+                            const left = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const right = node.right ? depths.get(node.right) ?? -1 : -1;
                             if (Math.abs(left - right) > 1) return false;
                             depths.set(node, 1 + Math.max(left, right));
                             last = node;
@@ -400,5 +382,14 @@ export class BST<T> extends BinaryTree<T> {
         return balanced;
     }
 
+    protected _comparator: BSTComparator = (a, b) => a - b;
+
+    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP {
+        const compared = this._comparator(a, b);
+        if (compared > 0) return CP.gt;
+        else if (compared < 0) return CP.lt;
+        else return CP.eq;
+    }
+
     // --- end additional functions
 }

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

@@ -2,3 +2,10 @@ 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/src/data-structures/binary-tree/segment-tree.ts

@@ -1,7 +1,15 @@
-export type SegmentTreeNodeVal = number;
+import type {SegmentTreeNodeVal} from '../types';
 
 export class SegmentTreeNode {
+    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
+        this._start = start;
+        this._end = end;
+        this._sum = sum;
+        this._val = val || null;
+    }
+
     protected _start = 0;
+
     get start(): number {
         return this._start;
     }
@@ -11,6 +19,7 @@ export class SegmentTreeNode {
     }
 
     protected _end = 0;
+
     get end(): number {
         return this._end;
     }
@@ -20,6 +29,7 @@ export class SegmentTreeNode {
     }
 
     protected _val: SegmentTreeNodeVal | null = null;
+
     get val(): SegmentTreeNodeVal | null {
         return this._val;
     }
@@ -29,6 +39,7 @@ export class SegmentTreeNode {
     }
 
     protected _sum = 0;
+
     get sum(): number {
         return this._sum;
     }
@@ -38,6 +49,7 @@ export class SegmentTreeNode {
     }
 
     protected _left: SegmentTreeNode | null = null;
+
     get left(): SegmentTreeNode | null {
         return this._left;
     }
@@ -47,6 +59,7 @@ export class SegmentTreeNode {
     }
 
     protected _right: SegmentTreeNode | null = null;
+
     get right(): SegmentTreeNode | null {
         return this._right;
     }
@@ -54,23 +67,12 @@ export class SegmentTreeNode {
     set right(v: SegmentTreeNode | null) {
         this._right = v;
     }
-
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null) {
-        this._start = start;
-        this._end = end;
-        this._sum = sum;
-        this._val = val || null;
-    }
 }
 
 export class SegmentTree {
     protected _values: number[] = [];
     protected _start = 0;
     protected _end: number;
-    protected _root: SegmentTreeNode | null;
-    get root(): SegmentTreeNode | null {
-        return this._root;
-    }
 
     constructor(values: number[], start?: number, end?: number) {
         start = start || 0;
@@ -81,6 +83,12 @@ export class SegmentTree {
         this._root = this.build(start, end);
     }
 
+    protected _root: SegmentTreeNode | null;
+
+    get root(): SegmentTreeNode | null {
+        return this._root;
+    }
+
     build(start: number, end: number): SegmentTreeNode {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);

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

@@ -1,8 +1,5 @@
 import {BST, BSTNode} from './bst';
-import {BinaryTreeNodeId} from './binary-tree';
-
-export type TreeMultiSetDeletedResult<T> = { deleted: BSTNode<T> | null, needBalanced: BSTNode<T> | null };
-
+import type {BinaryTreeNodeId, TreeMultiSetDeletedResult} from '../types';
 
 export class TreeMultiSet<T> extends BST<T> {
     override createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T> {

package/src/data-structures/diagrams/README.md

@@ -0,0 +1,7 @@
+// 操作      常见名称       Ada           Java        JavaScript     C++          Python      Perl       PHP             Ruby
+// 尾部插入   inject, snoc Append         offerLast   push          push_back    append      push        array_push      push
+// 头部插入   push, cons   Prepend        offerFirst  unshift       push_front   appendleft  unshift     array_unshift   unshift
+// 尾部删除   eject        Delete_Last    pollLast    pop           pop_back     pop         pop         array_pop       pop
+// 头部删除   pop          Delete_First   pollFirst   shift         pop_front    popleft     shift       array_shift     shift
+// 查看尾部                Last_Element   peekLast    [length - 1]  back         [-1]        $array[-1]  end             last
+// 查看头部                First_Element  peekFirst   [0]           front        [0]         $array[0]   reset           first

package/src/data-structures/graph/abstract-graph.ts

@@ -1,60 +1,14 @@
 import {arrayRemove, uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
-
-export type VertexId = string | number;
-export type DijkstraResult<V> =
-    { distMap: Map<V, number>, preMap: Map<V, V | null>, seen: Set<V>, paths: V[][], minDist: number, minPath: V[] }
-    | null;
-
-export interface I_Graph<V, E> {
-
-    containsVertex(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[];
-
-    containsEdge(src: V | VertexId, dest: V | VertexId): boolean;
-
-    // containsEdge(e: E): boolean;
-
-    getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-
-    // getAllEdges(src: V, dest: V): E[];
-
-    edgeSet(): E[];
-
-    addEdge(edge: E): boolean;
-
-    removeEdgeBetween(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
-
-    removeEdge(edge: E): E | null;
-
-    // removeAllEdges(v1: VertexId | V, v2: VertexId | V): (E | null)[];
-
-    // removeAllEdges(edges: E[] | [VertexId, VertexId]): boolean;
-
-    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[];
-}
+import type {DijkstraResult, IGraph, VertexId} from '../types';
 
 export class AbstractVertex {
+    constructor(id: VertexId) {
+        this._id = id;
+    }
+
     private _id: VertexId;
+
     public get id(): VertexId {
         return this._id;
     }
@@ -62,15 +16,20 @@ export class AbstractVertex {
     public set id(v: VertexId) {
         this._id = v;
     }
-
-    constructor(id: VertexId) {
-        this._id = id;
-    }
 }
 
 export abstract class AbstractEdge {
 
+    static DEFAULT_EDGE_WEIGHT = 1;
+
+    protected constructor(weight?: number) {
+        if (weight === undefined) weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
+        this._weight = weight;
+        this._hashCode = uuidV4();
+    }
+
     private _weight: number;
+
     get weight(): number {
         return this._weight;
     }
@@ -88,18 +47,10 @@ export abstract class AbstractEdge {
     set hashCode(v: string) {
         this._hashCode = v;
     }
-
-    protected constructor(weight?: number) {
-        if (weight === undefined) weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
-        this._weight = weight;
-        this._hashCode = uuidV4();
-    }
-
-    static DEFAULT_EDGE_WEIGHT = 1;
 }
 
 // Connected Component === Largest Connected Sub-Graph
-export abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements I_Graph<V, E> {
+export abstract class AbstractGraph<V extends AbstractVertex, E extends AbstractEdge> implements IGraph<V, E> {
 
     protected _vertices: Map<VertexId, V> = new Map<VertexId, V>();
 
@@ -192,7 +143,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
                 if (!visiting.get(neighbor)) {
                     path.push(neighbor);
                     dfs(neighbor, dest, visiting, path);
-                    arrayRemove(path, vertex => vertex === neighbor);
+                    arrayRemove(path, (vertex: AbstractVertex) => vertex === neighbor);
                 }
             }
 
@@ -296,7 +247,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
                     if (!visiting.get(neighbor)) {
                         path.push(neighbor);
                         dfs(neighbor, dest, visiting, path);
-                        arrayRemove(path, vertex => vertex === neighbor);
+                        arrayRemove(path, (vertex: AbstractVertex) => vertex === neighbor);
                     }
                 }
 
@@ -338,7 +289,8 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         }
 
         for (const vertex of vertices) {
-            distMap.set(vertex[1], Infinity);
+            const vertexOrId = vertex[1];
+            if (vertexOrId instanceof AbstractVertex) distMap.set(vertexOrId, Infinity);
         }
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
@@ -359,15 +311,19 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
 
         const getPaths = (minV: V | null) => {
             for (const vertex of vertices) {
-                const path: V[] = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
+                const vertexOrId = vertex[1];
+
+                if (vertexOrId instanceof AbstractVertex) {
+                    const path: V[] = [vertexOrId];
+                    let parent = preMap.get(vertexOrId);
+                    while (parent) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
+                    }
+                    const reversed = path.reverse();
+                    if (vertex[1] === minV) minPath = reversed;
+                    paths.push(reversed);
                 }
-                const reversed = path.reverse();
-                if (vertex[1] === minV) minPath = reversed;
-                paths.push(reversed);
             }
         };
 
@@ -449,7 +405,8 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         }
 
         for (const vertex of vertices) {
-            distMap.set(vertex[1], Infinity);
+            const vertexOrId = vertex[1];
+            if (vertexOrId instanceof AbstractVertex) distMap.set(vertexOrId, Infinity);
         }
 
         const heap = new PriorityQueue<{ id: number, val: V }>({comparator: (a, b) => a.id - b.id});
@@ -460,15 +417,19 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
 
         const getPaths = (minV: V | null) => {
             for (const vertex of vertices) {
-                const path: V[] = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
+                const vertexOrId = vertex[1];
+                if (vertexOrId instanceof AbstractVertex) {
+                    const path: V[] = [vertexOrId];
+                    let parent = preMap.get(vertexOrId);
+                    while (parent) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
+                    }
+                    const reversed = path.reverse();
+                    if (vertex[1] === minV) minPath = reversed;
+                    paths.push(reversed);
                 }
-                const reversed = path.reverse();
-                if (vertex[1] === minV) minPath = reversed;
-                paths.push(reversed);
+
             }
         };
 
@@ -551,7 +512,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         let min = Infinity;
         let minPath: V[] = [];
         // TODO
-        let hasNegativeCycle: boolean | undefined = undefined;
+        let hasNegativeCycle: boolean | undefined;
         if (scanNegativeCycle) hasNegativeCycle = false;
         if (!srcVertex) return {hasNegativeCycle, distMap, preMap, paths, min, minPath};
 
@@ -598,15 +559,18 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
 
         if (genPath) {
             for (const vertex of vertices) {
-                const path: V[] = [vertex[1]];
-                let parent = preMap.get(vertex[1]);
-                while (parent !== undefined) {
-                    path.push(parent);
-                    parent = preMap.get(parent);
+                const vertexOrId = vertex[1];
+                if (vertexOrId instanceof AbstractVertex) {
+                    const path: V[] = [vertexOrId];
+                    let parent = preMap.get(vertexOrId);
+                    while (parent !== undefined) {
+                        path.push(parent);
+                        parent = preMap.get(parent);
+                    }
+                    const reversed = path.reverse();
+                    if (vertex[1] === minDest) minPath = reversed;
+                    paths.push(reversed);
                 }
-                const reversed = path.reverse();
-                if (vertex[1] === minDest) minPath = reversed;
-                paths.push(reversed);
             }
         }
 

package/src/data-structures/graph/directed-graph.ts

@@ -1,5 +1,6 @@
 import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
+import type {IDirectedGraph, TopologicalStatus, VertexId} from '../types';
 
 export class DirectedVertex extends AbstractVertex {
     constructor(id: VertexId) {
@@ -34,25 +35,8 @@ export class DirectedEdge extends AbstractEdge {
     }
 }
 
-export interface I_DirectedGraph<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;
-}
-
-// 0 means unknown, 1 means visiting, 2 means visited;
-export type TopologicalStatus = 0 | 1 | 2;
-
 // Strongly connected, One direction connected, Weakly connected
-export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements I_DirectedGraph<V, E> {
+export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> extends AbstractGraph<V, E> implements IDirectedGraph<V, E> {
 
     protected _outEdgeMap: Map<V, E[]> = new Map<V, E[]>();
 
@@ -120,12 +104,12 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
 
         const srcOutEdges = this._outEdgeMap.get(src);
         if (srcOutEdges) {
-            arrayRemove<E>(srcOutEdges, edge => edge.dest === dest.id);
+            arrayRemove<E>(srcOutEdges, (edge: DirectedEdge) => edge.dest === dest.id);
         }
 
         const destInEdges = this._inEdgeMap.get(dest);
         if (destInEdges) {
-            removed = arrayRemove<E>(destInEdges, edge => edge.src === src.id)[0] || null;
+            removed = arrayRemove<E>(destInEdges, (edge: DirectedEdge) => edge.src === src.id)[0] || null;
         }
         return removed;
     }
@@ -137,12 +121,12 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         if (src && dest) {
             const srcOutEdges = this._outEdgeMap.get(src);
             if (srcOutEdges && srcOutEdges.length > 0) {
-                arrayRemove(srcOutEdges, edge => edge.src === src.id);
+                arrayRemove(srcOutEdges, (edge: DirectedEdge) => edge.src === src.id);
             }
 
             const destInEdges = this._inEdgeMap.get(dest);
             if (destInEdges && destInEdges.length > 0) {
-                removed = arrayRemove(destInEdges, edge => edge.dest === dest.id)[0];
+                removed = arrayRemove(destInEdges, (edge: DirectedEdge) => edge.dest === dest.id)[0];
             }
 
         }
@@ -194,7 +178,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         return this.getVertex(e.dest);
     }
 
-    getDestinations(vertex: V | null): V[] {
+    getDestinations(vertex: V | VertexId | null): V[] {
         if (vertex === null) {
             return [];
         }
@@ -215,7 +199,7 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
      */
-    topologicalSort(): V[] | null {
+    topologicalSort(): (V | VertexId)[] | null {
         // vector<vector<int>> g;
         // vector<int> color;
         // int last;
@@ -247,14 +231,14 @@ export class DirectedGraph<V extends DirectedVertex, E extends DirectedEdge> ext
         // }
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
-        const statusMap: Map<V, TopologicalStatus> = new Map<V, TopologicalStatus>();
+        const statusMap: Map<V | VertexId, TopologicalStatus> = new Map<V, TopologicalStatus>();
         for (const entry of this._vertices) {
             statusMap.set(entry[1], 0);
         }
 
-        const sorted: V[] = [];
+        const sorted: (V | VertexId)[] = [];
         let hasCycle = false;
-        const dfs = (cur: V) => {
+        const dfs = (cur: V | VertexId) => {
             statusMap.set(cur, 1);
             const children = this.getDestinations(cur);
             for (const child of children) {

package/src/data-structures/graph/undirected-graph.ts

@@ -1,5 +1,6 @@
 import {arrayRemove} from '../../utils';
-import {AbstractEdge, AbstractGraph, AbstractVertex, VertexId} from './abstract-graph';
+import {AbstractEdge, AbstractGraph, AbstractVertex} from './abstract-graph';
+import type {VertexId} from '../types';
 
 export class UndirectedVertex extends AbstractVertex {
     constructor(id: VertexId) {
@@ -8,6 +9,11 @@ export class UndirectedVertex extends AbstractVertex {
 }
 
 export class UndirectedEdge extends AbstractEdge {
+    constructor(v1: VertexId, v2: VertexId, weight?: number) {
+        super(weight);
+        this._vertices = [v1, v2];
+    }
+
     private _vertices: [VertexId, VertexId];
 
     public get vertices() {
@@ -17,20 +23,15 @@ export class UndirectedEdge extends AbstractEdge {
     public set vertices(v: [VertexId, VertexId]) {
         this._vertices = v;
     }
-
-    constructor(v1: VertexId, v2: VertexId, weight?: number) {
-        super(weight);
-        this._vertices = [v1, v2];
-    }
 }
 
 export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdge> extends AbstractGraph<V, E> {
+    protected _edges: Map<V, E[]> = new Map();
+
     constructor() {
         super();
     }
 
-    protected _edges: Map<V, E[]> = new Map();
-
     getEdge(v1: V | null | VertexId, v2: V | null | VertexId): E | null {
         let edges: E[] | undefined = [];
 
@@ -74,11 +75,11 @@ export class UndirectedGraph<V extends UndirectedVertex, E extends UndirectedEdg
         const v1Edges = this._edges.get(vertex1);
         let removed: E | null = null;
         if (v1Edges) {
-            removed = arrayRemove<E>(v1Edges, e => e.vertices.includes(vertex2.id))[0] || null;
+            removed = arrayRemove<E>(v1Edges, (e: UndirectedEdge) => e.vertices.includes(vertex2.id))[0] || null;
         }
         const v2Edges = this._edges.get(vertex2);
         if (v2Edges) {
-            arrayRemove<E>(v2Edges, e => e.vertices.includes(vertex1.id));
+            arrayRemove<E>(v2Edges, (e: UndirectedEdge) => e.vertices.includes(vertex1.id));
         }
         return removed;
     }

package/src/data-structures/hash/coordinate-map.ts

@@ -1,4 +1,4 @@
-export class CoordinateSet<V> extends Map<any, V> {
+export class CoordinateMap<V> extends Map<any, V> {
     private readonly _joint: string = '_';
 
     constructor(joint?: string) {

package/src/data-structures/hash/index.ts

@@ -1 +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';

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

@@ -1,17 +1,8 @@
 import {PriorityQueue} from '../priority-queue';
-
-export interface HeapOptions<T> {
-    priority?: (element: T) => number;
-}
-
-export interface HeapItem<T> {
-    priority: number;
-    element: T | null;
-}
-
+import type {HeapItem, HeapOptions} from '../types';
 
 /**
- * @copyright 2021 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  *
  * @abstract