data-structure-typed 0.8.17 → 0.9.16

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

@@ -1,84 +1,82 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
-class PriorityQueue {
-    get size() {
-        return this.nodes.length;
-    }
-    constructor(options) {
+var PriorityQueue = /** @class */ (function () {
+    function PriorityQueue(options) {
         this.nodes = [];
-        this._comparator = (a, b) => {
-            const aKey = a, bKey = b;
+        this._comparator = function (a, b) {
+            var aKey = a, bKey = b;
             return aKey - bKey;
         };
-        const { nodes, comparator, isFix = true } = options;
+        var nodes = options.nodes, comparator = options.comparator, _a = options.isFix, isFix = _a === void 0 ? true : _a;
         this._comparator = comparator;
         if (nodes && nodes instanceof Array && nodes.length > 0) {
             // TODO support distinct
-            this.nodes = Array.isArray(nodes) ? [...nodes] : [];
+            this.nodes = Array.isArray(nodes) ? __spreadArray([], __read(nodes), false) : [];
             isFix && this._fix();
         }
     }
-    _compare(a, b) {
-        return this._comparator(this.nodes[a], this.nodes[b]) > 0;
-    }
-    _swap(a, b) {
-        const temp = this.nodes[a];
-        this.nodes[a] = this.nodes[b];
-        this.nodes[b] = temp;
-    }
-    _isValidIndex(index) {
-        return index > -1 && index < this.nodes.length;
-    }
-    _getParent(child) {
-        return Math.floor((child - 1) / 2);
-    }
-    _getLeft(parent) {
-        return (2 * parent) + 1;
-    }
-    _getRight(parent) {
-        return (2 * parent) + 2;
-    }
-    _getComparedChild(parent) {
-        let min = parent;
-        const left = this._getLeft(parent), right = this._getRight(parent);
-        if (left < this.size && this._compare(min, left)) {
-            min = left;
-        }
-        if (right < this.size && this._compare(min, right)) {
-            min = right;
-        }
-        return min;
-    }
-    _heapifyUp(start) {
-        while (start > 0 && this._compare(this._getParent(start), start)) {
-            const parent = this._getParent(start);
-            this._swap(start, parent);
-            start = parent;
-        }
-    }
-    _heapifyDown(start) {
-        let min = this._getComparedChild(start);
-        while (this._compare(start, min)) {
-            this._swap(min, start);
-            start = min;
-            min = this._getComparedChild(start);
-        }
-    }
-    _fix() {
-        for (let i = Math.floor(this.size / 2); i > -1; i--)
-            this._heapifyDown(i);
-    }
-    offer(node) {
+    Object.defineProperty(PriorityQueue.prototype, "size", {
+        get: function () {
+            return this.nodes.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PriorityQueue.heapify = function (options) {
+        var heap = new PriorityQueue(options);
+        heap._fix();
+        return heap;
+    };
+    PriorityQueue.isPriorityQueueified = function (options) {
+        return new PriorityQueue(__assign(__assign({}, options), { isFix: true })).isValid();
+    };
+    PriorityQueue.prototype.offer = function (node) {
         this.nodes.push(node);
         this._heapifyUp(this.size - 1);
-    }
-    peek() {
+    };
+    PriorityQueue.prototype.peek = function () {
         return this.size ? this.nodes[0] : null;
-    }
-    poll() {
+    };
+    PriorityQueue.prototype.poll = function () {
         var _a, _b;
-        let res = null;
+        var res = null;
         if (this.size > 1) {
             this._swap(0, this.nodes.length - 1);
             res = (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
@@ -88,87 +86,132 @@ class PriorityQueue {
             res = (_b = this.nodes.pop()) !== null && _b !== void 0 ? _b : null;
         }
         return res;
-    }
-    leaf() {
+    };
+    PriorityQueue.prototype.leaf = function () {
         var _a;
         return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
-    }
-    isEmpty() {
+    };
+    PriorityQueue.prototype.isEmpty = function () {
         return this.size === 0;
-    }
-    clear() {
+    };
+    PriorityQueue.prototype.clear = function () {
         this.nodes = [];
-    }
-    toArray() {
-        return [...this.nodes];
-    }
-    clone() {
+    };
+    PriorityQueue.prototype.toArray = function () {
+        return __spreadArray([], __read(this.nodes), false);
+    };
+    PriorityQueue.prototype.clone = function () {
         return new PriorityQueue({ nodes: this.nodes, comparator: this._comparator });
-    }
+    };
     // --- start additional methods ---
-    isValid() {
-        const isValidRecursive = (parentIndex) => {
-            let isValidLeft = true;
-            let isValidRight = true;
-            if (this._getLeft(parentIndex) !== -1) {
-                const leftChildIndex = (parentIndex * 2) + 1;
-                if (!this._compare(parentIndex, leftChildIndex))
+    PriorityQueue.prototype.isValid = function () {
+        var _this = this;
+        var isValidRecursive = function (parentIndex) {
+            var isValidLeft = true;
+            var isValidRight = true;
+            if (_this._getLeft(parentIndex) !== -1) {
+                var leftChildIndex = (parentIndex * 2) + 1;
+                if (!_this._compare(parentIndex, leftChildIndex))
                     return false;
                 isValidLeft = isValidRecursive(leftChildIndex);
             }
-            if (this._getRight(parentIndex) !== -1) {
-                const rightChildIndex = (parentIndex * 2) + 2;
-                if (!this._compare(parentIndex, rightChildIndex))
+            if (_this._getRight(parentIndex) !== -1) {
+                var rightChildIndex = (parentIndex * 2) + 2;
+                if (!_this._compare(parentIndex, rightChildIndex))
                     return false;
                 isValidRight = isValidRecursive(rightChildIndex);
             }
             return isValidLeft && isValidRight;
         };
         return isValidRecursive(0);
-    }
-    sort() {
-        const visitedNode = [];
+    };
+    PriorityQueue.prototype.sort = function () {
+        var visitedNode = [];
         while (this.size !== 0) {
-            const top = this.poll();
+            var top = this.poll();
             if (top)
                 visitedNode.push(top);
         }
         return visitedNode;
-    }
-    DFS(dfsMode) {
-        const visitedNode = [];
-        const traverse = (cur) => {
+    };
+    PriorityQueue.prototype.DFS = function (dfsMode) {
+        var _this = this;
+        var visitedNode = [];
+        var traverse = function (cur) {
             var _a, _b, _c;
-            const leftChildIndex = this._getLeft(cur);
-            const rightChildIndex = this._getRight(cur);
+            var leftChildIndex = _this._getLeft(cur);
+            var rightChildIndex = _this._getRight(cur);
             switch (dfsMode) {
                 case 'in':
-                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    visitedNode.push((_a = this.nodes[cur]) !== null && _a !== void 0 ? _a : null);
-                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    visitedNode.push((_a = _this.nodes[cur]) !== null && _a !== void 0 ? _a : null);
+                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
                     break;
                 case 'pre':
-                    visitedNode.push((_b = this.nodes[cur]) !== null && _b !== void 0 ? _b : null);
-                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push((_b = _this.nodes[cur]) !== null && _b !== void 0 ? _b : null);
+                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
                     break;
                 case 'post':
-                    this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
-                    this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
-                    visitedNode.push((_c = this.nodes[cur]) !== null && _c !== void 0 ? _c : null);
+                    _this._isValidIndex(leftChildIndex) && traverse(leftChildIndex);
+                    _this._isValidIndex(rightChildIndex) && traverse(rightChildIndex);
+                    visitedNode.push((_c = _this.nodes[cur]) !== null && _c !== void 0 ? _c : null);
                     break;
             }
         };
         this._isValidIndex(0) && traverse(0);
         return visitedNode;
-    }
-    static heapify(options) {
-        const heap = new PriorityQueue(options);
-        heap._fix();
-        return heap;
-    }
-    static isPriorityQueueified(options) {
-        return new PriorityQueue(Object.assign(Object.assign({}, options), { isFix: true })).isValid();
-    }
-}
+    };
+    PriorityQueue.prototype._compare = function (a, b) {
+        return this._comparator(this.nodes[a], this.nodes[b]) > 0;
+    };
+    PriorityQueue.prototype._swap = function (a, b) {
+        var temp = this.nodes[a];
+        this.nodes[a] = this.nodes[b];
+        this.nodes[b] = temp;
+    };
+    PriorityQueue.prototype._isValidIndex = function (index) {
+        return index > -1 && index < this.nodes.length;
+    };
+    PriorityQueue.prototype._getParent = function (child) {
+        return Math.floor((child - 1) / 2);
+    };
+    PriorityQueue.prototype._getLeft = function (parent) {
+        return (2 * parent) + 1;
+    };
+    PriorityQueue.prototype._getRight = function (parent) {
+        return (2 * parent) + 2;
+    };
+    PriorityQueue.prototype._getComparedChild = function (parent) {
+        var min = parent;
+        var left = this._getLeft(parent), right = this._getRight(parent);
+        if (left < this.size && this._compare(min, left)) {
+            min = left;
+        }
+        if (right < this.size && this._compare(min, right)) {
+            min = right;
+        }
+        return min;
+    };
+    PriorityQueue.prototype._heapifyUp = function (start) {
+        while (start > 0 && this._compare(this._getParent(start), start)) {
+            var parent = this._getParent(start);
+            this._swap(start, parent);
+            start = parent;
+        }
+    };
+    PriorityQueue.prototype._heapifyDown = function (start) {
+        var min = this._getComparedChild(start);
+        while (this._compare(start, min)) {
+            this._swap(min, start);
+            start = min;
+            min = this._getComparedChild(start);
+        }
+    };
+    PriorityQueue.prototype._fix = function () {
+        for (var i = Math.floor(this.size / 2); i > -1; i--)
+            this._heapifyDown(i);
+    };
+    return PriorityQueue;
+}());
 exports.PriorityQueue = PriorityQueue;

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

@@ -1,17 +1,37 @@
 "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 __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
-const linked_list_1 = require("../linked-list");
+var 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 {
-}
+var Deque = /** @class */ (function (_super) {
+    __extends(Deque, _super);
+    function Deque() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return Deque;
+}(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) {
+var ObjectDeque = /** @class */ (function () {
+    function ObjectDeque(capacity) {
         this._nodes = {};
         this._capacity = Number.MAX_SAFE_INTEGER;
         this._first = -1;
@@ -20,12 +40,12 @@ class ObjectDeque {
         if (capacity !== undefined)
             this._capacity = capacity;
     }
-    size() {
+    ObjectDeque.prototype.size = function () {
         return this._size;
-    }
-    offerFirst(value) {
+    };
+    ObjectDeque.prototype.offerFirst = function (value) {
         if (this._size === 0) {
-            const mid = Math.floor(this._capacity / 2);
+            var mid = Math.floor(this._capacity / 2);
             this._first = mid;
             this._last = mid;
         }
@@ -34,10 +54,10 @@ class ObjectDeque {
         }
         this._nodes[this._first] = value;
         this._size++;
-    }
-    offerLast(value) {
+    };
+    ObjectDeque.prototype.offerLast = function (value) {
         if (this._size === 0) {
-            const mid = Math.floor(this._capacity / 2);
+            var mid = Math.floor(this._capacity / 2);
             this._first = mid;
             this._last = mid;
         }
@@ -46,87 +66,93 @@ class ObjectDeque {
         }
         this._nodes[this._last] = value;
         this._size++;
-    }
-    pollFirst() {
+    };
+    ObjectDeque.prototype.pollFirst = function () {
         if (!this._size)
             return;
-        let value = this.peekFirst();
+        var value = this.peekFirst();
         delete this._nodes[this._first];
         this._first++;
         this._size--;
         return value;
-    }
-    peekFirst() {
+    };
+    ObjectDeque.prototype.peekFirst = function () {
         if (this._size)
             return this._nodes[this._first];
-    }
-    pollLast() {
+    };
+    ObjectDeque.prototype.pollLast = function () {
         if (!this._size)
             return;
-        let value = this.peekLast();
+        var value = this.peekLast();
         delete this._nodes[this._last];
         this._last--;
         this._size--;
         return value;
-    }
-    peekLast() {
+    };
+    ObjectDeque.prototype.peekLast = function () {
         if (this._size)
             return this._nodes[this._last];
-    }
-    get(index) {
+    };
+    ObjectDeque.prototype.get = function (index) {
         return this._nodes[this._first + index] || null;
-    }
-    isEmpty() {
+    };
+    ObjectDeque.prototype.isEmpty = function () {
         return this._size <= 0;
-    }
-}
+    };
+    return ObjectDeque;
+}());
 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() {
+var ArrayDeque = /** @class */ (function () {
+    function ArrayDeque() {
         this._nodes = [];
     }
-    get size() {
-        return this._nodes.length;
-    }
-    offerLast(value) {
+    Object.defineProperty(ArrayDeque.prototype, "size", {
+        get: function () {
+            return this._nodes.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ArrayDeque.prototype.offerLast = function (value) {
         return this._nodes.push(value);
-    }
-    pollLast() {
+    };
+    ArrayDeque.prototype.pollLast = function () {
         var _a;
         return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
-    }
-    pollFirst() {
+    };
+    ArrayDeque.prototype.pollFirst = function () {
         var _a;
         return (_a = this._nodes.shift()) !== null && _a !== void 0 ? _a : null;
-    }
-    offerFirst(value) {
+    };
+    ArrayDeque.prototype.offerFirst = function (value) {
         return this._nodes.unshift(value);
-    }
-    peekFirst() {
+    };
+    ArrayDeque.prototype.peekFirst = function () {
         var _a;
         return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    peekLast() {
+    };
+    ArrayDeque.prototype.peekLast = function () {
         var _a;
         return (_a = this._nodes[this._nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
-    }
-    get(index) {
+    };
+    ArrayDeque.prototype.get = function (index) {
         var _a;
         return (_a = this._nodes[index]) !== null && _a !== void 0 ? _a : null;
-    }
-    set(index, value) {
+    };
+    ArrayDeque.prototype.set = function (index, value) {
         return this._nodes[index] = value;
-    }
-    insert(index, value) {
+    };
+    ArrayDeque.prototype.insert = function (index, value) {
         return this._nodes.splice(index, 0, value);
-    }
-    remove(index) {
+    };
+    ArrayDeque.prototype.remove = function (index) {
         return this._nodes.splice(index, 1);
-    }
-    isEmpty() {
+    };
+    ArrayDeque.prototype.isEmpty = function () {
         return this._nodes.length === 0;
-    }
-}
+    };
+    return ArrayDeque;
+}());
 exports.ArrayDeque = ArrayDeque;

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

@@ -1 +1,2 @@
 export * from './queue';
+export * from './deque';

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

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./queue"), exports);
+__exportStar(require("./deque"), exports);

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

@@ -1,7 +1,6 @@
 /**
  * @license MIT
- * @copyright 2020 Pablo
- *
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
 export declare class Queue<T> {
@@ -12,6 +11,14 @@ export declare class Queue<T> {
      * @param {array} [elements]
      */
     constructor(elements?: T[]);
+    /**
+     * Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {array} elements
+     * @return {Queue}
+     */
+    static fromArray<T>(elements: T[]): Queue<T>;
     /**
      * Adds an element at the back of the queue.
      * @public
@@ -65,12 +72,4 @@ export declare class Queue<T> {
      * @return {Queue}
      */
     clone(): Queue<T>;
-    /**
-     * Creates a queue from an existing array.
-     * @public
-     * @static
-     * @param {array} elements
-     * @return {Queue}
-     */
-    static fromArray<T>(elements: T[]): Queue<T>;
 }