linked-list-typed 2.1.0 → 2.1.2

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

@@ -1,3 +0,0 @@
-export * from './max-heap';
-export * from './min-heap';
-export * from './heap';

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

@@ -1,19 +0,0 @@
-"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("./max-heap"), exports);
-__exportStar(require("./min-heap"), exports);
-__exportStar(require("./heap"), exports);

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

@@ -1,32 +0,0 @@
-/**
- * data-structure-typed
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { HeapOptions } from '../../types';
-import { Heap } from './heap';
-/**
- * @template E
- * @template R
- * Max-oriented binary heap.
- * Notes and typical use-cases are documented in {@link Heap}.
- *
- * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. Heap Properties: The value of each parent node is greater than or equal to the value of its children.
- * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
- * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
- * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
- * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
- * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.
- * @example
- */
-export declare class MaxHeap<E = any, R = any> extends Heap<E, R> {
-    /**
-     * Create a max-heap. For objects, supply a custom comparator.
-     * @param elements Optional initial elements.
-     * @param options Optional configuration.
-     */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: HeapOptions<E, R>);
-}

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MaxHeap = void 0;
-const heap_1 = require("./heap");
-/**
- * @template E
- * @template R
- * Max-oriented binary heap.
- * Notes and typical use-cases are documented in {@link Heap}.
- *
- * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. Heap Properties: The value of each parent node is greater than or equal to the value of its children.
- * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
- * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
- * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
- * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
- * 7. Efficient Sorting Algorithms: For example, heap sort. Heap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum-spanning tree algorithm, which use heaps to improve performance.
- * @example
- */
-class MaxHeap extends heap_1.Heap {
-    /**
-     * Create a max-heap. For objects, supply a custom comparator.
-     * @param elements Optional initial elements.
-     * @param options Optional configuration.
-     */
-    constructor(elements = [], options) {
-        super(elements, Object.assign({ comparator: (a, b) => {
-                if (typeof a === 'object' || typeof b === 'object') {
-                    throw TypeError(`When comparing object types, a custom comparator must be defined in the constructor's options parameter.`);
-                }
-                if (a < b)
-                    return 1;
-                if (a > b)
-                    return -1;
-                return 0;
-            } }, options));
-    }
-}
-exports.MaxHeap = MaxHeap;

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

@@ -1,33 +0,0 @@
-/**
- * @remarks Time O(n log n), Space O(n).
- * data-structure-typed
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
-import type { HeapOptions } from '../../types';
-import { Heap } from './heap';
-/**
- * @template E
- * @template R
- * Min-oriented binary heap.
- * Notes and typical use-cases are documented in {@link Heap}.
- *
- * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.
- * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
- * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
- * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
- * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
- * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
- * @example
- */
-export declare class MinHeap<E = any, R = any> extends Heap<E, R> {
-    /**
-     * Create a min-heap.
-     * @param elements Optional initial elements.
-     * @param options Optional configuration.
-     */
-    constructor(elements?: Iterable<E> | Iterable<R>, options?: HeapOptions<E, R>);
-}

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MinHeap = void 0;
-const heap_1 = require("./heap");
-/**
- * @template E
- * @template R
- * Min-oriented binary heap.
- * Notes and typical use-cases are documented in {@link Heap}.
- *
- * 1. Complete Binary Tree: Heaps are typically complete binary trees, meaning every level is fully filled except possibly for the last level, which has nodes as far left as possible.
- * 2. MinHeap Properties:  The value of each parent node is less than or equal to the value of its children.
- * 3. Root Node Access: In a heap, the largest element (in a max heap) or the smallest element (in a min heap) is always at the root of the tree.
- * 4. Efficient Insertion and Deletion: Due to its structure, a heap allows for insertion and deletion operations in logarithmic time (O(log n)).
- * 5. Managing Dynamic Data Sets: Heaps effectively manage dynamic data sets, especially when frequent access to the largest or smallest elements is required.
- * 6. Non-linear Search: While a heap allows rapid access to its largest or smallest element, it is less efficient for other operations, such as searching for a specific element, as it is not designed for these tasks.
- * 7. Efficient Sorting Algorithms: For example, heap sort. MinHeap sort uses the properties of a heap to sort elements.
- * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
- * @example
- */
-class MinHeap extends heap_1.Heap {
-    /**
-     * Create a min-heap.
-     * @param elements Optional initial elements.
-     * @param options Optional configuration.
-     */
-    constructor(elements = [], options) {
-        super(elements, options);
-    }
-}
-exports.MinHeap = MinHeap;

package/dist/data-structures/index.js

@@ -1,28 +0,0 @@
-"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("./hash"), exports);
-__exportStar(require("./linked-list"), exports);
-__exportStar(require("./stack"), exports);
-__exportStar(require("./queue"), exports);
-__exportStar(require("./graph"), exports);
-__exportStar(require("./binary-tree"), exports);
-__exportStar(require("./heap"), exports);
-__exportStar(require("./priority-queue"), exports);
-__exportStar(require("./matrix"), exports);
-__exportStar(require("./trie"), exports);
-__exportStar(require("./base"), exports);
-__exportStar(require("./tree"), exports);