data-structure-typed 0.8.6

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
+const linked_list_1 = require("../linked-list");
+// O(n) time complexity of obtaining the value
+// O(1) time complexity of adding at the beginning and the end
+class Deque extends linked_list_1.DoublyLinkedList {
+}
+exports.Deque = Deque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+// todo tested slowest one
+class ObjectDeque {
+    constructor(capacity) {
+        this._nodes = {};
+        this._capacity = Number.MAX_SAFE_INTEGER;
+        this._first = -1;
+        this._last = -1;
+        this._size = 0;
+        if (capacity !== undefined)
+            this._capacity = capacity;
+    }
+    size() {
+        return this._size;
+    }
+    offerFirst(value) {
+        if (this._size === 0) {
+            const mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._first--;
+        }
+        this._nodes[this._first] = value;
+        this._size++;
+    }
+    offerLast(value) {
+        if (this._size === 0) {
+            const mid = Math.floor(this._capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._last++;
+        }
+        this._nodes[this._last] = value;
+        this._size++;
+    }
+    pollFirst() {
+        if (!this._size)
+            return;
+        let value = this.peekFirst();
+        delete this._nodes[this._first];
+        this._first++;
+        this._size--;
+        return value;
+    }
+    peekFirst() {
+        if (this._size)
+            return this._nodes[this._first];
+    }
+    pollLast() {
+        if (!this._size)
+            return;
+        let value = this.peekLast();
+        delete this._nodes[this._last];
+        this._last--;
+        this._size--;
+        return value;
+    }
+    peekLast() {
+        if (this._size)
+            return this._nodes[this._last];
+    }
+    get(index) {
+        return this._nodes[this._first + index] || null;
+    }
+    isEmpty() {
+        return this._size <= 0;
+    }
+}
+exports.ObjectDeque = ObjectDeque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+class ArrayDeque {
+    constructor() {
+        this._nodes = [];
+    }
+    get size() {
+        return this._nodes.length;
+    }
+    offerLast(value) {
+        return this._nodes.push(value);
+    }
+    pollLast() {
+        var _a;
+        return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
+    }
+    pollFirst() {
+        var _a;
+        return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
+    }
+    offerFirst(value) {
+        return this._nodes.unshift(value);
+    }
+    peekFirst() {
+        var _a;
+        return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    peekLast() {
+        var _a;
+        return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
+    }
+    get(index) {
+        var _a;
+        return (_a = this._nodes[index]) !== null && _a !== void 0 ? _a : null;
+    }
+    set(index, value) {
+        return this._nodes[index] = value;
+    }
+    insert(index, value) {
+        return this._nodes.splice(index, 0, value);
+    }
+    remove(index) {
+        return this._nodes.splice(index, 1);
+    }
+    isEmpty() {
+        return this._nodes.length === 0;
+    }
+}
+exports.ArrayDeque = ArrayDeque;

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

@@ -0,0 +1,17 @@
+"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("./queue"), exports);

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+/**
+ * @license MIT
+ * @copyright 2020 Pablo
+ *
+ * @class
+ */
+class Queue {
+    /**
+     * Creates a queue.
+     * @param {array} [elements]
+     */
+    constructor(elements) {
+        this._nodes = elements || [];
+        this._offset = 0;
+    }
+    /**
+     * Adds an element at the back of the queue.
+     * @public
+     * @param {any} element
+     */
+    offer(element) {
+        this._nodes.push(element);
+        return this;
+    }
+    /**
+     * Dequeues the front element in the queue.
+     * @public
+     * @returns {any}
+     */
+    poll() {
+        if (this.size() === 0)
+            return null;
+        const first = this.peek();
+        this._offset += 1;
+        if (this._offset * 2 < this._nodes.length)
+            return first;
+        // only remove dequeued elements when reaching half size
+        // to decrease latency of shifting elements.
+        this._nodes = this._nodes.slice(this._offset);
+        this._offset = 0;
+        return first;
+    }
+    /**
+     * Returns the front element of the queue.
+     * @public
+     * @returns {any}
+     */
+    peek() {
+        return this.size() > 0 ? this._nodes[this._offset] : null;
+    }
+    /**
+     * Returns the back element of the queue.
+     * @public
+     * @returns {any}
+     */
+    peekLast() {
+        return this.size() > 0 ? this._nodes[this._nodes.length - 1] : null;
+    }
+    /**
+     * Returns the number of elements in the queue.
+     * @public
+     * @returns {number}
+     */
+    size() {
+        return this._nodes.length - this._offset;
+    }
+    /**
+     * Checks if the queue is empty.
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty() {
+        return this.size() === 0;
+    }
+    /**
+     * Returns the remaining elements in the queue as an array.
+     * @public
+     * @returns {array}
+     */
+    toArray() {
+        return this._nodes.slice(this._offset);
+    }
+    /**
+     * Clears the queue.
+     * @public
+     */
+    clear() {
+        this._nodes = [];
+        this._offset = 0;
+    }
+    /**
+     * Creates a shallow copy of the queue.
+     * @public
+     * @return {Queue}
+     */
+    clone() {
+        return new Queue(this._nodes.slice(this._offset));
+    }
+    /**
+     * Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {array} elements
+     * @return {Queue}
+     */
+    static fromArray(elements) {
+        return new Queue(elements);
+    }
+}
+exports.Queue = Queue;

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

@@ -0,0 +1,17 @@
+"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("./stack"), exports);

package/dist/data-structures/stack/stack.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stack = void 0;
+/**
+ * @license MIT
+ * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ *
+ * @class
+ */
+class Stack {
+    /**
+     * Creates a stack.
+     * @param {array} [elements]
+     */
+    constructor(elements) {
+        this._elements = Array.isArray(elements) ? elements : [];
+    }
+    /**
+     * Checks if the stack is empty.
+     * @public
+     * @returns {boolean}
+     */
+    isEmpty() {
+        return this._elements.length === 0;
+    }
+    /**
+     * Returns the number of elements in the stack.
+     * @public
+     * @returns {number}
+     */
+    size() {
+        return this._elements.length;
+    }
+    /**
+     * Returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    peek() {
+        if (this.isEmpty())
+            return null;
+        return this._elements[this._elements.length - 1];
+    }
+    /**
+     * Adds an element to the top of the stack.
+     * @public
+     * @param {object} element
+     */
+    push(element) {
+        this._elements.push(element);
+        return this;
+    }
+    /**
+     * Removes and returns the top element in the stack.
+     * @public
+     * @returns {object}
+     */
+    pop() {
+        if (this.isEmpty())
+            return null;
+        return this._elements.pop() || null;
+    }
+    /**
+     * Returns the remaining elements as an array.
+     * @public
+     * @returns {array}
+     */
+    toArray() {
+        return this._elements.slice();
+    }
+    /**
+     * Clears all elements from the stack.
+     * @public
+     */
+    clear() {
+        this._elements = [];
+    }
+    /**
+     * Creates a shallow copy from the stack.
+     * @public
+     * @return {Stack}
+     */
+    clone() {
+        return new Stack(this._elements.slice());
+    }
+    /**
+     * Creates a stack from an existing array
+     * @public
+     * @static
+     * @param {array} [elements]
+     * @return {Stack}
+     */
+    static fromArray(elements) {
+        return new Stack(elements);
+    }
+}
+exports.Stack = Stack;

package/dist/data-structures/trampoline.js

@@ -0,0 +1,52 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trampolineAsync = exports.trampoline = exports.toThunk = exports.isThunk = exports.THUNK_SYMBOL = void 0;
+exports.THUNK_SYMBOL = Symbol('thunk');
+const isThunk = (value) => {
+    return typeof value === 'function' && value.__THUNK__ === exports.THUNK_SYMBOL;
+};
+exports.isThunk = isThunk;
+const toThunk = (fn) => {
+    const thunk = () => fn();
+    thunk.__THUNK__ = exports.THUNK_SYMBOL;
+    return thunk;
+};
+exports.toThunk = toThunk;
+const trampoline = (fn) => {
+    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
+    return Object.assign((...args) => {
+        let result = fn(...args);
+        while ((0, exports.isThunk)(result)) {
+            result = result();
+        }
+        return result;
+    }, { cont });
+};
+exports.trampoline = trampoline;
+const trampolineAsync = (fn) => {
+    const cont = (...args) => (0, exports.toThunk)(() => fn(...args));
+    return Object.assign((...args) => __awaiter(void 0, void 0, void 0, function* () {
+        let result = yield fn(...args);
+        while ((0, exports.isThunk)(result)) {
+            result = yield result();
+        }
+        return result;
+    }), { cont });
+};
+exports.trampolineAsync = trampolineAsync;
+const factorial = (0, exports.trampoline)((n, acc = 1) => {
+    return n
+        // Note: calling factorial.cont instead of factorial directly
+        ? factorial.cont(n - 1, acc * n)
+        : acc;
+});
+// factorial(32768)

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

@@ -0,0 +1,17 @@
+"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("./trie"), exports);

package/dist/data-structures/trie/trie.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trie = exports.TrieNode = void 0;
+class TrieNode {
+    constructor() {
+        this._children = new Map();
+        this._isEnd = false;
+    }
+    get children() {
+        return this._children;
+    }
+    set children(v) {
+        this._children = v;
+    }
+    get isEnd() {
+        return this._isEnd;
+    }
+    set isEnd(v) {
+        this._isEnd = v;
+    }
+}
+exports.TrieNode = TrieNode;
+class Trie {
+    get root() {
+        return this._root;
+    }
+    set root(v) {
+        this._root = v;
+    }
+    constructor() {
+        this._root = new TrieNode();
+    }
+    put(input) {
+        let cur = this._root;
+        for (const c of input) {
+            let nodeC = cur.children.get(c);
+            if (!nodeC) {
+                nodeC = new TrieNode();
+                cur.children.set(c, nodeC);
+            }
+            cur = nodeC;
+        }
+        cur.isEnd = true;
+        return true;
+    }
+    has(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return cur.isEnd;
+    }
+    remove(word) {
+        let isDeleted = false;
+        const dfs = (cur, i) => {
+            const char = word[i];
+            const child = cur.children.get(char);
+            if (child) {
+                if (i === word.length - 1) {
+                    if (child.isEnd) {
+                        if (child.children.size > 0) {
+                            child.isEnd = false;
+                        }
+                        else {
+                            cur.children.delete(char);
+                        }
+                        isDeleted = true;
+                        return true;
+                    }
+                    return false;
+                }
+                const res = dfs(child, i + 1);
+                if (res && !cur.isEnd && child.children.size === 0) {
+                    cur.children.delete(char);
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        };
+        dfs(this.root, 0);
+        return isDeleted;
+    }
+    // --- start additional methods ---
+    /**
+     * Only can present as a prefix, not a word
+     * @param input
+     */
+    isAbsPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return !cur.isEnd;
+    }
+    /**
+     * Can present as a prefix or word
+     * @param input
+     */
+    isPrefix(input) {
+        let cur = this._root;
+        for (const c of input) {
+            const nodeC = cur.children.get(c);
+            if (!nodeC)
+                return false;
+            cur = nodeC;
+        }
+        return true;
+    }
+    getAll(prefix = '') {
+        const words = [];
+        function dfs(node, word) {
+            for (const char of node.children.keys()) {
+                const charNode = node.children.get(char);
+                if (charNode !== undefined) {
+                    dfs(charNode, word.concat(char));
+                }
+            }
+            if (node.isEnd) {
+                words.push(word);
+            }
+        }
+        let startNode = this._root;
+        if (prefix) {
+            for (const c of prefix) {
+                const nodeC = startNode.children.get(c);
+                if (nodeC)
+                    startNode = nodeC;
+            }
+        }
+        dfs(startNode, prefix);
+        return words;
+    }
+}
+exports.Trie = Trie;

package/dist/index.js

@@ -0,0 +1,17 @@
+"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("./data-structures"), exports);

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

@@ -0,0 +1,2 @@
+export declare class AaTree {
+}

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

@@ -0,0 +1,21 @@
+import { BST, BSTNode } from './bst';
+import { BinaryTreeNodeId } from './binary-tree';
+export interface AVLTreeDeleted<T> {
+    deleted: AVLTreeNode<T> | null;
+    needBalanced: AVLTreeNode<T> | null;
+}
+export declare class AVLTreeNode<T> extends BSTNode<T> {
+    clone(): AVLTreeNode<T>;
+}
+export declare class AVLTree<T> extends BST<T> {
+    createNode(id: BinaryTreeNodeId, val: T, count?: number): AVLTreeNode<T>;
+    put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null;
+    remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): AVLTreeDeleted<T>[];
+    balanceFactor(node: AVLTreeNode<T>): number;
+    updateHeight(node: AVLTreeNode<T>): void;
+    balancePath(node: AVLTreeNode<T>): void;
+    balanceLL(A: AVLTreeNode<T>): void;
+    balanceLR(A: AVLTreeNode<T>): void;
+    balanceRR(A: AVLTreeNode<T>): void;
+    balanceRL(A: AVLTreeNode<T>): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class BTree {
+}

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

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