data-structure-typed 0.8.18 → 0.9.16

package/.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/data-structure-ts.iml" filepath="$PROJECT_DIR$/.idea/data-structure-ts.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/data-structure-typed.iml" filepath="$PROJECT_DIR$/.idea/data-structure-typed.iml" />
     </modules>
   </component>
 </project>

package/README.md

@@ -1,2 +1,197 @@
-# data-structure-ts
-Hash (CoordinateSet, CoordinateMap) Heap (MaxHeap, MinHeap) Binary Tree (AVL Tree, Binary Indexed Tree, Binary Search Tree, Segment Tree, Tree Multiset) Graph (Directed Graph, Undirected Graph) Linked List (Singly Linked List, Doubly Linked List) Matrix Priority Queue (Max Priority Queue, Min Priority Queue) Queue (Queue, Dequeue) Stack Trie
+# data-structure-typed
+
+## install
+
+### yarn
+
+```bash
+yarn add data-structure-typed
+```
+
+### npm
+
+```bash
+npm install data-structure-typed
+```
+
+## data structures
+
+<table>
+<thead>
+  <tr>
+    <th>Data Structure</th>
+    <th>Derived</th>
+    <th>Basic Features</th>
+    <th>Additional Features</th>
+  </tr>
+</thead>
+
+<tbody>
+<tr>
+    <td>Binary Tree</td>
+    <td>AVL Tree, Binary Search Tree, Tree Multiset</td>
+    <td>put, has, get, remove, size, insertTo, insertMany, fill, getDepth, getHeight, getMinHeight, getPathToRoot, isBalanced </td>
+    <td>getLeftMost, isBST, getSubTreeSizeAndCount, subTreeSum, subTreeAdd, BFS, DFS, DFSIterative, levelIterative, listLevels, getPredecessor, morris,  </td>
+  </tr>
+
+  <tr>
+    <td>AVL Tree</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree, balanceFactor, updateHeight, balancePath, balanceLL, balanceLR, balanceRR, balanceRL</td>
+    <td></td>
+  </tr>
+
+  <tr>
+    <td>Binary Search Tree (BST)</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree, lastKey</td>
+    <td>All the features inherited from Binary Tree, lesserSum, allGreaterNodesAdd, balance, isAVLBalanced</td>
+  </tr>
+
+  <tr>
+    <td>Tree Multiset</td>
+    <td></td>
+    <td>All the features inherited from Binary Tree</td>
+    <td>All the features inherited from Binary Tree</td>
+  </tr>
+
+  <tr>
+    <td>Segment Tree</td>
+    <td></td>
+    <td>build, updateNode, querySumByRange</td>
+    <td></td>
+  </tr>
+
+  <tr>
+    <td>Binary Indexed Tree</td>
+    <td></td>
+    <td>update, getPrefixSum, getRangeSum, BinaryIndexedTree.lowBit</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Graph</td>
+    <td>Directed Graph, Undirected Graph</td>
+    <td>getVertex, getVertexId, containsVertex, vertexSet, addVertex, removeVertex, removeAllVertices, containsEdge, setEdgeWeight, getAllPathsBetween, getPathSumWeight, getMinCostBetween, getMinPathBetween, </td>
+    <td>dijkstra, dijkstraWithoutHeap, bellmanFord, floyd, tarjan</td>
+  </tr>
+  <tr>
+    <td>Directed Graph</td>
+    <td></td>
+    <td>All the features inherited from Graph, getEdge, addEdge, removeEdgeBetween, removeEdge, removeAllEdges, incomingEdgesOf, outgoingEdgesOf, degreeOf, inDegreeOf, outDegreeOf, edgesOf, getEdgeSrc, getEdgeDest, getDestinations, edgeSet, getNeighbors, getEndsOfEdge</td>
+    <td>All the features inherited from Graph, topologicalSort</td>
+  </tr>
+  <tr>
+    <td>Undirected Graph</td>
+    <td></td>
+    <td>All the features inherited from Graph, getEdge, addEdge, removeEdgeBetween, removeEdge, degreeOf, edgesOf, edgeSet, getEdgesOf, getNeighbors, getEndsOfEdge</td>
+    <td>All the features inherited from Graph</td>
+  </tr>
+  <tr>
+    <td>Singly Linked List</td>
+    <td></td>
+    <td>length, head, tail, size, get, getNode, findNodeIndex, findNode, find, findIndex, append, push, prepend, insertAt, removeNode, removeAt, insertBefore, sort, insertAfter, shift, pop, merge, clear, slice, reverse, forEach, map, filter, reduce, toArray, toString</td>
+    <td></td>
+
+  </tr>
+  <tr>
+    <td>Hash</td>
+    <td>CoordinateSet, CoordinateMap</td>
+    <td></td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>CoordinateSet</td>
+    <td></td>
+    <td>has, set, get, delete</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>CoordinateMap</td>
+    <td></td>
+    <td>has, add, delete</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Heap</td>
+    <td></td>
+    <td></td>
+  </tr>
+
+
+  <tr>
+    <td>Doubly Linked List</td>
+    <td></td>
+    <td>size, offerFirst, offerLast, peekFirst, peekLast, pollFirst, pollLast, get, isEmpty, insert, remove, </td>
+    <td></td>
+  </tr>
+
+[//]: # (  <tr>)
+
+[//]: # (    <td>Matrix</td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (    <td></td>)
+
+[//]: # (  </tr>)
+
+  <tr>
+    <td>Priority Queue</td>
+    <td>Max Priority Queue, Min Priority Queue</td>
+    <td>offer, peek, poll, leaf, isEmpty, clear, toArray, clone</td>
+    <td>isValid, sort, DFS</td>
+  </tr>
+  <tr>
+    <td>Max Priority Queue</td>
+    <td></td>
+    <td>All the features inherited from Priority Queue</td>
+    <td>All the features inherited from Priority Queue</td>
+  </tr>
+  <tr>
+    <td>Min Priority Queue</td>
+    <td></td>
+    <td>All the features inherited from Priority Queue</td>
+    <td>All the features inherited from Priority Queue</td>
+  </tr>
+  <tr>
+    <td>Queue</td>
+    <td>Queue, Dequeue</td>
+    <td>offer, poll, peek, peekLast, size, isEmpty, toArray, clear, clone, Queue.fromArray</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>ObjectDeque</td>
+    <td></td>
+    <td>size, offerFirst, offerLast, pollFirst, peekFirst, pollLast, peekLast, get, isEmpty</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>ArrayDeque</td>
+    <td></td>
+    <td>offerLast, pollLast, pollFirst, offerFirst, peekFirst, peekLast, get, set, insert, remove, isEmpty</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Stack</td>
+    <td></td>
+    <td>isEmpty, size, peek, push, pop, toArray, clear, clone, Stack.fromArray</td>
+    <td></td>
+  </tr>
+  <tr>
+    <td>Trie</td>
+    <td></td>
+    <td>put, has, remove, isAbsPrefix, isPrefix, getAll</td>
+    <td></td>
+  </tr>
+</tbody>
+
+</table>
+
+
+
+
+![complexities](src/assets/complexities-diff.jpg)
+
+![complexities of data structures](src/assets/data-structure-complexities.jpg)

package/dist/data-structures/binary-tree/aa-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AaTree = void 0;
-class AaTree {
-}
+var AaTree = /** @class */ (function () {
+    function AaTree() {
+    }
+    return AaTree;
+}());
 exports.AaTree = AaTree;

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

@@ -1,9 +1,5 @@
 import { BST, BSTNode } from './bst';
-import { BinaryTreeNodeId } from './binary-tree';
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
+import type { AVLTreeDeleted, BinaryTreeNodeId } from '../types';
 export declare class AVLTreeNode<T> extends BSTNode<T> {
     clone(): AVLTreeNode<T>;
 }

package/dist/data-structures/binary-tree/avl-tree.js

@@ -1,57 +1,103 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTree = exports.AVLTreeNode = void 0;
-const bst_1 = require("./bst");
-class AVLTreeNode extends bst_1.BSTNode {
-    clone() {
-        return new AVLTreeNode(this.id, this.val, this.count);
+var bst_1 = require("./bst");
+var AVLTreeNode = /** @class */ (function (_super) {
+    __extends(AVLTreeNode, _super);
+    function AVLTreeNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
+    AVLTreeNode.prototype.clone = function () {
+        return new AVLTreeNode(this.id, this.val, this.count);
+    };
+    return AVLTreeNode;
+}(bst_1.BSTNode));
 exports.AVLTreeNode = AVLTreeNode;
-class AVLTree extends bst_1.BST {
-    createNode(id, val, count) {
-        return new AVLTreeNode(id, val, count);
+var AVLTree = /** @class */ (function (_super) {
+    __extends(AVLTree, _super);
+    function AVLTree() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    put(id, val, count) {
-        const inserted = super.put(id, val, count);
+    AVLTree.prototype.createNode = function (id, val, count) {
+        return new AVLTreeNode(id, val, count);
+    };
+    AVLTree.prototype.put = function (id, val, count) {
+        var inserted = _super.prototype.put.call(this, id, val, count);
         if (inserted)
             this.balancePath(inserted);
         return inserted;
-    }
-    remove(id, isUpdateAllLeftSum) {
-        const deletedResults = super.remove(id, isUpdateAllLeftSum);
-        for (const { needBalanced } of deletedResults) {
-            if (needBalanced) {
-                this.balancePath(needBalanced);
+    };
+    AVLTree.prototype.remove = function (id, isUpdateAllLeftSum) {
+        var e_1, _a;
+        var deletedResults = _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
+        try {
+            for (var deletedResults_1 = __values(deletedResults), deletedResults_1_1 = deletedResults_1.next(); !deletedResults_1_1.done; deletedResults_1_1 = deletedResults_1.next()) {
+                var needBalanced = deletedResults_1_1.value.needBalanced;
+                if (needBalanced) {
+                    this.balancePath(needBalanced);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (deletedResults_1_1 && !deletedResults_1_1.done && (_a = deletedResults_1.return)) _a.call(deletedResults_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
         return deletedResults;
-    }
-    balanceFactor(node) {
+    };
+    AVLTree.prototype.balanceFactor = function (node) {
         if (!node.right) // node has no right subtree
             return -node.height;
         else if (!node.left) // node has no left subtree
             return +node.height;
         else
             return node.right.height - node.left.height;
-    }
-    updateHeight(node) {
+    };
+    AVLTree.prototype.updateHeight = function (node) {
         if (!node.left && !node.right) // node is a leaf
             node.height = 0;
         else if (!node.left) {
             // node has no left subtree
-            const rightHeight = node.right ? node.right.height : 0;
+            var rightHeight = node.right ? node.right.height : 0;
             node.height = 1 + rightHeight;
         }
         else if (!node.right) // node has no right subtree
             node.height = 1 + node.left.height;
         else
             node.height = 1 + Math.max(node.right.height, node.left.height);
-    }
-    balancePath(node) {
-        const path = this.getPathToRoot(node);
-        for (let i = path.length - 1; i >= 0; i--) {
-            const A = path[i];
+    };
+    AVLTree.prototype.balancePath = function (node) {
+        var path = this.getPathToRoot(node);
+        for (var i = path.length - 1; i >= 0; i--) {
+            var A = path[i];
             this.updateHeight(A);
             switch (this.balanceFactor(A)) {
                 case -2:
@@ -75,10 +121,10 @@ class AVLTree extends bst_1.BST {
                     }
             }
         }
-    }
-    balanceLL(A) {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy and B is left-heavy
+    };
+    AVLTree.prototype.balanceLL = function (A) {
+        var parentOfA = A.parent;
+        var B = A.left; // A is left-heavy and B is left-heavy
         A.parent = B;
         if (B && B.right) {
             B.right.parent = A;
@@ -105,11 +151,11 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A);
         if (B)
             this.updateHeight(B);
-    }
-    balanceLR(A) {
-        const parentOfA = A.parent;
-        const B = A.left; // A is left-heavy
-        let C = null;
+    };
+    AVLTree.prototype.balanceLR = function (A) {
+        var parentOfA = A.parent;
+        var B = A.left; // A is left-heavy
+        var C = null;
         if (B) {
             C = B.right; // B is right-heavy
         }
@@ -150,10 +196,10 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    }
-    balanceRR(A) {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy and B is right-heavy
+    };
+    AVLTree.prototype.balanceRR = function (A) {
+        var parentOfA = A.parent;
+        var B = A.right; // A is right-heavy and B is right-heavy
         A.parent = B;
         if (B) {
             if (B.left) {
@@ -181,11 +227,11 @@ class AVLTree extends bst_1.BST {
         }
         this.updateHeight(A);
         B && this.updateHeight(B);
-    }
-    balanceRL(A) {
-        const parentOfA = A.parent;
-        const B = A.right; // A is right-heavy
-        let C = null;
+    };
+    AVLTree.prototype.balanceRL = function (A) {
+        var parentOfA = A.parent;
+        var B = A.right; // A is right-heavy
+        var C = null;
         if (B) {
             C = B.left; // B is left-heavy
         }
@@ -226,6 +272,7 @@ class AVLTree extends bst_1.BST {
         this.updateHeight(A); // Adjust heights
         B && this.updateHeight(B);
         C && this.updateHeight(C);
-    }
-}
+    };
+    return AVLTree;
+}(bst_1.BST));
 exports.AVLTree = AVLTree;

package/dist/data-structures/binary-tree/b-tree.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BTree = void 0;
-class BTree {
-}
+var BTree = /** @class */ (function () {
+    function BTree() {
+    }
+    return BTree;
+}());
 exports.BTree = BTree;

package/dist/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -1,8 +1,8 @@
 export declare class BinaryIndexedTree {
     private readonly _sumTree;
     constructor(n: number);
+    static lowBit(x: number): number;
     update(i: number, delta: number): void;
     getPrefixSum(i: number): number;
     getRangeSum(start: number, end: number): number;
-    static lowBit(x: number): number;
 }

package/dist/data-structures/binary-tree/binary-indexed-tree.js

@@ -1,31 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryIndexedTree = void 0;
-class BinaryIndexedTree {
-    constructor(n) {
+var BinaryIndexedTree = /** @class */ (function () {
+    function BinaryIndexedTree(n) {
         this._sumTree = new Array(n + 1).fill(0);
     }
-    update(i, delta) {
+    BinaryIndexedTree.lowBit = function (x) {
+        return x & (-x);
+    };
+    BinaryIndexedTree.prototype.update = function (i, delta) {
         while (i < this._sumTree.length) {
             this._sumTree[i] += delta;
             i += BinaryIndexedTree.lowBit(i);
         }
-    }
-    getPrefixSum(i) {
-        let sum = 0;
+    };
+    BinaryIndexedTree.prototype.getPrefixSum = function (i) {
+        var sum = 0;
         while (i > 0) {
             sum += this._sumTree[i];
             i -= BinaryIndexedTree.lowBit(i);
         }
         return sum;
-    }
-    getRangeSum(start, end) {
+    };
+    BinaryIndexedTree.prototype.getRangeSum = function (start, end) {
         if (!(0 <= start && start <= end && end <= this._sumTree.length))
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
-    }
-    static lowBit(x) {
-        return x & (-x);
-    }
-}
+    };
+    return BinaryIndexedTree;
+}());
 exports.BinaryIndexedTree = BinaryIndexedTree;

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

@@ -1,18 +1,4 @@
-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>[];
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
-}
+import type { BinaryTreeDeleted, BinaryTreeNodeId, BinaryTreeNodePropertyName, DFSOrderPattern, NodeOrPropertyName, ResultsByProperty } from '../types';
 export declare enum FamilyPosition {
     root = 0,
     left = 1,
@@ -23,6 +9,7 @@ export declare enum LoopType {
     recursive = 2
 }
 export declare class BinaryTreeNode<T> {
+    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     protected _id: BinaryTreeNodeId;
     get id(): BinaryTreeNodeId;
     set id(v: BinaryTreeNodeId);
@@ -47,35 +34,34 @@ export declare class BinaryTreeNode<T> {
     protected _height: number;
     get height(): number;
     set height(v: number);
-    constructor(id: BinaryTreeNodeId, val: T, count?: number);
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T>;
     clone(): BinaryTreeNode<T>;
 }
 export declare class BinaryTree<T> {
-    protected _root: BinaryTreeNode<T> | null;
-    get root(): BinaryTreeNode<T> | null;
-    protected set root(v: BinaryTreeNode<T> | null);
-    protected _size: number;
-    get size(): number;
-    protected set size(v: number);
-    protected _count: number;
-    get count(): number;
-    protected set count(v: number);
-    private readonly _autoIncrementId;
-    private _maxId;
-    private readonly _isDuplicatedVal;
     protected _loopType: LoopType;
     protected _visitedId: BinaryTreeNodeId[];
     protected _visitedVal: Array<T>;
     protected _visitedNode: BinaryTreeNode<T>[];
     protected _visitedCount: number[];
     protected _visitedLeftSum: number[];
-    protected _resetResults(): void;
+    private readonly _autoIncrementId;
+    private _maxId;
+    private readonly _isDuplicatedVal;
     constructor(options?: {
         loopType?: LoopType;
         autoIncrementId?: boolean;
         isDuplicatedVal?: boolean;
     });
+    protected _root: BinaryTreeNode<T> | null;
+    protected get root(): BinaryTreeNode<T> | null;
+    protected set root(v: BinaryTreeNode<T> | null);
+    protected _size: number;
+    protected get size(): number;
+    protected set size(v: number);
+    protected _count: number;
+    protected get count(): number;
+    protected set count(v: number);
+    getCount(): number;
     createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null;
     clear(): void;
     isEmpty(): boolean;
@@ -95,9 +81,7 @@ export declare class BinaryTree<T> {
     has(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): boolean;
     get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BinaryTreeNode<T> | null;
     getPathToRoot(node: BinaryTreeNode<T>): BinaryTreeNode<T>[];
-    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
-    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
-    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
+    getRoot(): BinaryTreeNode<T> | null;
     getLeftMost(): BinaryTreeNode<T> | null;
     getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
     getRightMost(): BinaryTreeNode<T> | null;
@@ -137,4 +121,8 @@ export declare class BinaryTree<T> {
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    protected _resetResults(): void;
+    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): boolean | undefined;
+    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName?: NodeOrPropertyName): void;
+    protected _getResultByPropertyName(nodeOrPropertyName?: NodeOrPropertyName): ResultsByProperty<T>;
 }