data-structure-typed 0.8.18 → 0.9.16

package/dist/data-structures/heap/max-heap.js

@@ -1,22 +1,40 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
+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.MaxHeap = void 0;
-const heap_1 = require("./heap");
-const priority_queue_1 = require("../priority-queue");
+var heap_1 = require("./heap");
+var priority_queue_1 = require("../priority-queue");
 /**
  * @class MaxHeap
  * @extends Heap
  */
-class MaxHeap extends heap_1.Heap {
-    constructor(options) {
-        super(options);
-        this._pq = new priority_queue_1.PriorityQueue({
-            comparator: (a, b) => b.priority - a.priority
+var MaxHeap = /** @class */ (function (_super) {
+    __extends(MaxHeap, _super);
+    function MaxHeap(options) {
+        var _this = _super.call(this, options) || this;
+        _this._pq = new priority_queue_1.PriorityQueue({
+            comparator: function (a, b) { return b.priority - a.priority; }
         });
+        return _this;
     }
-}
+    return MaxHeap;
+}(heap_1.Heap));
 exports.MaxHeap = MaxHeap;

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

@@ -1,9 +1,10 @@
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
-import { Heap, HeapItem, HeapOptions } from './heap';
+import { Heap } from './heap';
 import { PriorityQueue } from '../priority-queue';
+import type { HeapItem, HeapOptions } from '../types';
 /**
  * @class MinHeap
  * @extends Heap

package/dist/data-structures/heap/min-heap.js

@@ -1,22 +1,40 @@
 "use strict";
 /**
- * @copyright 2020 Pablo Rios <zrwusa@gmail.com>
+ * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
+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.MinHeap = void 0;
-const heap_1 = require("./heap");
-const priority_queue_1 = require("../priority-queue");
+var heap_1 = require("./heap");
+var priority_queue_1 = require("../priority-queue");
 /**
  * @class MinHeap
  * @extends Heap
  */
-class MinHeap extends heap_1.Heap {
-    constructor(options) {
-        super(options);
-        this._pq = new priority_queue_1.PriorityQueue({
-            comparator: (a, b) => a.priority - b.priority
+var MinHeap = /** @class */ (function (_super) {
+    __extends(MinHeap, _super);
+    function MinHeap(options) {
+        var _this = _super.call(this, options) || this;
+        _this._pq = new priority_queue_1.PriorityQueue({
+            comparator: function (a, b) { return a.priority - b.priority; }
         });
+        return _this;
     }
-}
+    return MinHeap;
+}(heap_1.Heap));
 exports.MinHeap = MinHeap;

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

@@ -8,3 +8,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './types';

package/dist/data-structures/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);
 __exportStar(require("./trie"), exports);
+__exportStar(require("./types"), exports);

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

@@ -4,7 +4,6 @@ export declare class DoublyLinkedListNode<T> {
     prev: DoublyLinkedListNode<T> | null;
     constructor(nodeValue: T);
 }
-export type DoublyLinkedListGetBy = 'node' | 'val';
 export declare class DoublyLinkedList<T> {
     private _first;
     private _last;

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -1,40 +1,38 @@
 "use strict";
-// 操作      常见名称       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
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoublyLinkedList = exports.DoublyLinkedListNode = void 0;
-class DoublyLinkedListNode {
-    constructor(nodeValue) {
+var DoublyLinkedListNode = /** @class */ (function () {
+    function DoublyLinkedListNode(nodeValue) {
         this.val = nodeValue;
         this.next = null;
         this.prev = null;
     }
-}
+    return DoublyLinkedListNode;
+}());
 exports.DoublyLinkedListNode = DoublyLinkedListNode;
-class DoublyLinkedList {
-    constructor() {
+var DoublyLinkedList = /** @class */ (function () {
+    function DoublyLinkedList() {
         this._first = null;
         this._last = null;
         this._size = 0;
         // --- end extra methods ---
     }
-    get size() {
-        return this._size;
-    }
-    set size(v) {
-        this._size = v;
-    }
+    Object.defineProperty(DoublyLinkedList.prototype, "size", {
+        get: function () {
+            return this._size;
+        },
+        set: function (v) {
+            this._size = v;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Adds a node at the beginning of the linked list
      * @param val Value to be stored at the beginning of the linked list
      */
-    offerFirst(val) {
-        const newNode = new DoublyLinkedListNode(val);
+    DoublyLinkedList.prototype.offerFirst = function (val) {
+        var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
             this._last = newNode;
@@ -47,13 +45,13 @@ class DoublyLinkedList {
         }
         this._size++;
         return true;
-    }
+    };
     /**
      * Adds a node to the end of the linked list
      * @param val Value to be stored in the Doubly linked list node
      */
-    offerLast(val) {
-        const newNode = new DoublyLinkedListNode(val);
+    DoublyLinkedList.prototype.offerLast = function (val) {
+        var newNode = new DoublyLinkedListNode(val);
         if (this._size === 0) {
             this._first = newNode;
             this._last = newNode;
@@ -66,8 +64,8 @@ class DoublyLinkedList {
         }
         this._size++;
         return true;
-    }
-    peekFirst(by) {
+    };
+    DoublyLinkedList.prototype.peekFirst = function (by) {
         var _a, _b, _c, _d, _e;
         switch (by) {
             case 'node':
@@ -77,9 +75,10 @@ class DoublyLinkedList {
             default:
                 return (_e = (_d = this._first) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
         }
-    }
-    peekLast(by = 'val') {
+    };
+    DoublyLinkedList.prototype.peekLast = function (by) {
         var _a, _b, _c, _d, _e;
+        if (by === void 0) { by = 'val'; }
         switch (by) {
             case 'node':
                 return (_a = this._last) !== null && _a !== void 0 ? _a : null;
@@ -88,15 +87,16 @@ class DoublyLinkedList {
             default:
                 return (_e = (_d = this._last) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
         }
-    }
+    };
     /**
      * Removes a node form the beginning of the linked list and will return the node val
      */
-    pollFirst(by = 'val') {
+    DoublyLinkedList.prototype.pollFirst = function (by) {
         var _a, _b, _c;
+        if (by === void 0) { by = 'val'; }
         if (this._size === 0)
             return null;
-        const oldHead = this._first;
+        var oldHead = this._first;
         if (this._size === 1) {
             this._first = null;
             this._last = null;
@@ -117,15 +117,16 @@ class DoublyLinkedList {
             default:
                 return (_c = oldHead === null || oldHead === void 0 ? void 0 : oldHead.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
+    };
     /**
      * Removes a node at the end of the linked list and will return the node value
      */
-    pollLast(by = 'val') {
+    DoublyLinkedList.prototype.pollLast = function (by) {
         var _a, _b, _c;
+        if (by === void 0) { by = 'val'; }
         if (this._size === 0)
             return null;
-        const polled = this._last;
+        var polled = this._last;
         if (this._size === 1) {
             this._first = null;
             this._last = null;
@@ -146,7 +147,7 @@ class DoublyLinkedList {
             default:
                 return (_c = polled === null || polled === void 0 ? void 0 : polled.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
+    };
     /**
      * Returns the node at the specified index of the linked list.
      * If index = 0; first element in the list is returned.
@@ -154,11 +155,12 @@ class DoublyLinkedList {
      * @param index Index of the node to be retrieved
      * @param by Return value type
      */
-    get(index, by = 'val') {
+    DoublyLinkedList.prototype.get = function (index, by) {
         var _a, _b;
+        if (by === void 0) { by = 'val'; }
         if (index < 0 || index >= this._size)
             return null;
-        let count, current;
+        var count, current;
         if (index <= this._size / 2) {
             count = 0;
             current = this._first;
@@ -183,7 +185,7 @@ class DoublyLinkedList {
             default:
                 return (_b = current === null || current === void 0 ? void 0 : current.val) !== null && _b !== void 0 ? _b : null;
         }
-    }
+    };
     /**
      * Updates the value of the node at the specified index.
      * If index = 0; Value of the first element in the list is updated.
@@ -191,33 +193,33 @@ class DoublyLinkedList {
      * @param index Index of the node to be updated
      * @param val New value of the node
      */
-    set(index, val) {
-        const foundNode = this.get(index, 'node');
+    DoublyLinkedList.prototype.set = function (index, val) {
+        var foundNode = this.get(index, 'node');
         if (foundNode !== null) {
             foundNode.val = val;
             return true;
         }
         return false;
-    }
-    isEmpty() {
+    };
+    DoublyLinkedList.prototype.isEmpty = function () {
         return this._size === 0;
-    }
+    };
     // --- start extra methods ---
     /**
      * Inserts a new node at the specified index.
      * @param index Index at which the new node has to be inserted
      * @param val Value of the new node to be inserted
      */
-    insert(index, val) {
+    DoublyLinkedList.prototype.insert = function (index, val) {
         if (index < 0 || index > this._size)
             return false;
         if (index === 0)
             return !!this.offerFirst(val);
         if (index === this._size)
             return !!this.offerLast(val);
-        const newNode = new DoublyLinkedListNode(val);
-        const prevNode = this.get(index - 1, 'node');
-        const nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
+        var newNode = new DoublyLinkedListNode(val);
+        var prevNode = this.get(index - 1, 'node');
+        var nextNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
         if (prevNode)
             prevNode.next = newNode;
         newNode.prev = prevNode;
@@ -226,12 +228,12 @@ class DoublyLinkedList {
             nextNode.prev = newNode;
         this._size++;
         return true;
-    }
+    };
     /**
      * Removes a node at the specified index and returns its value.
      * @param index Index at which the node has to be removed.
      */
-    remove(index) {
+    DoublyLinkedList.prototype.remove = function (index) {
         var _a, _b, _c;
         if (index < 0 || index > this._size - 1)
             return null;
@@ -240,9 +242,9 @@ class DoublyLinkedList {
         else if (index === this._size - 1)
             return (_b = (_a = this.pollLast('node')) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : null;
         else {
-            const prevNode = this.get(index - 1, 'node');
-            const removeNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
-            const nextNode = removeNode === null || removeNode === void 0 ? void 0 : removeNode.next;
+            var prevNode = this.get(index - 1, 'node');
+            var removeNode = prevNode === null || prevNode === void 0 ? void 0 : prevNode.next;
+            var nextNode = removeNode === null || removeNode === void 0 ? void 0 : removeNode.next;
             if (prevNode)
                 prevNode.next = nextNode !== null && nextNode !== void 0 ? nextNode : null;
             if (nextNode)
@@ -254,6 +256,7 @@ class DoublyLinkedList {
             this._size--;
             return (_c = removeNode === null || removeNode === void 0 ? void 0 : removeNode.val) !== null && _c !== void 0 ? _c : null;
         }
-    }
-}
+    };
+    return DoublyLinkedList;
+}());
 exports.DoublyLinkedList = DoublyLinkedList;

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

@@ -1,7 +1,4 @@
-/** Type used for filter and find methods, returning a boolean */
-type TTestFunction<NodeData> = (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean;
-/** Type used for map and forEach methods, returning anything */
-type TMapFunction<NodeData> = (data: any, index: number, list: SinglyLinkedList<NodeData>) => any;
+import type { TMapFunction, TTestFunction } from '../types';
 /**
  * The class which represents one link or node in a linked list
  * ```ts
@@ -72,6 +69,13 @@ export declare class SinglyLinkedListNode<NodeData = any> {
  * ```
  */
 export declare class SinglyLinkedList<NodeData = any> {
+    /** The head of the list, the first node */
+    head: SinglyLinkedListNode<NodeData> | null;
+    /** The tail of the list, the last node */
+    tail: SinglyLinkedListNode<NodeData> | null;
+    /** Internal size reference */
+    private size;
+    constructor(...args: NodeData[]);
     /**
      * The length of the list
      */
@@ -85,13 +89,6 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param iterable Any iterable datatype like Array or Map
      */
     static from<T>(iterable: Iterable<T>): SinglyLinkedList<T>;
-    /** The head of the list, the first node */
-    head: SinglyLinkedListNode<NodeData> | null;
-    /** The tail of the list, the last node */
-    tail: SinglyLinkedListNode<NodeData> | null;
-    /** Internal size reference */
-    private size;
-    constructor(...args: NodeData[]);
     /**
      * Get the node val at a specified index, zero based
      * ```ts
@@ -355,4 +352,3 @@ export declare class SinglyLinkedList<NodeData = any> {
     /** Private helper function to reduce duplication of pop() and shift() methods */
     private removeFromAnyEnd;
 }
-export {};