data-structure-typed 1.15.2 → 1.16.1

package/README.md

@@ -15,6 +15,12 @@ Hash, Coordinate Set, Coordinate Map, Heap, Priority Queue, Max Priority Queue,
 
 # How
 
+## Live Examples
+
+[Live Examples](https://data-structure-typed-examples.vercel.app)
+
+<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
+
 ## install
 
 ### yarn
@@ -130,12 +136,6 @@ npm install data-structure-typed
     expect(bfsNodes[2].id).toBe(16);
 ```
 
-## Live Examples
-
-[//]: # ([Live Examples]&#40;https://data-structure-typed-examples.vercel.app&#41;)
-
-<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
-
 ### Directed Graph simple snippet
 
 ```typescript
@@ -733,41 +733,41 @@ describe('DirectedGraph Test3', () => {
 </tbody>
 </table>
 
-![overview diagram](src/assets/overview-diagram-of-data-structures.png)
+![overview diagram](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/overview-diagram-of-data-structures.png)
 
-![complexities](src/assets/complexities-diff.jpg)
+![complexities](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/complexities-diff.jpg)
 
-![complexities of data structures](src/assets/data-structure-complexities.jpg)
+![complexities of data structures](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/data-structure-complexities.jpg)
 
-![](src/data-structures/binary-tree/diagrams/bst-rotation.gif)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/bst-rotation.gif)
 
-![](src/data-structures/binary-tree/diagrams/avl-tree-inserting.gif)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/avl-tree-inserting.gif)
 
-![](src/data-structures/graph/diagrams/tarjan.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan.webp)
 
-![](src/data-structures/graph/diagrams/adjacency-list.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-list-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-matrix.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-matrix-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/dfs-can-do.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/dfs-can-do.jpg)
 
-![](src/data-structures/graph/diagrams/edge-list.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list.jpg)
 
-![](src/data-structures/graph/diagrams/edge-list-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/max-flow.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/max-flow.jpg)
 
-![](src/data-structures/graph/diagrams/mst.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/mst.jpg)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-articulation-point-bridge.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-articulation-point-bridge.png&#41;)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-complicate-simple.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-complicate-simple.png&#41;)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-strongly-connected-component.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-strongly-connected-component.png&#41;)
 
 
 

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

@@ -6,8 +6,17 @@
  * @license MIT License
  */
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
-export declare abstract class Heap<T> {
+import type { HeapOptions } from '../types';
+export declare class HeapItem<T = number> {
+    constructor(priority?: number, val?: T | null);
+    private _priority;
+    get priority(): number;
+    set priority(value: number);
+    private _val;
+    get val(): T | null;
+    set val(value: T | null);
+}
+export declare abstract class Heap<T = number> {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
@@ -17,9 +26,9 @@ export declare abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     get pq(): PriorityQueue<HeapItem<T>>;
     protected set pq(v: PriorityQueue<HeapItem<T>>);
-    protected _priorityCb: (element: T) => number;
-    get priorityCb(): (element: T) => number;
-    protected set priorityCb(v: (element: T) => number);
+    protected _priorityCb: (val: T) => number;
+    get priorityCb(): (val: T) => number;
+    protected set priorityCb(v: (val: T) => number);
     /**
      * The function returns the size of a priority queue.
      * @returns The size of the priority queue.
@@ -32,7 +41,7 @@ export declare abstract class Heap<T> {
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
-    getPriorityCb(): (element: T) => number;
+    getPriorityCb(): (val: T) => number;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
@@ -44,33 +53,39 @@ export declare abstract class Heap<T> {
     isEmpty(): boolean;
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     peek(): HeapItem<T> | null;
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null;
     /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    add(element: T, priority?: number): Heap<T>;
+    add(val: T, priority?: number): Heap<T>;
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null;
+    /**
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
+     */
+    has(node: T | HeapItem<T>): boolean;
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     toArray(): HeapItem<T>[];
     /**

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

@@ -1,6 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heap = void 0;
+exports.Heap = exports.HeapItem = void 0;
+var HeapItem = /** @class */ (function () {
+    function HeapItem(priority, val) {
+        if (priority === void 0) { priority = NaN; }
+        if (val === void 0) { val = null; }
+        this._val = val;
+        this._priority = priority;
+    }
+    Object.defineProperty(HeapItem.prototype, "priority", {
+        get: function () {
+            return this._priority;
+        },
+        set: function (value) {
+            this._priority = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HeapItem.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (value) {
+            this._val = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HeapItem;
+}());
+exports.HeapItem = HeapItem;
 var Heap = /** @class */ (function () {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
@@ -77,31 +107,31 @@ var Heap = /** @class */ (function () {
     };
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     Heap.prototype.peek = function () {
         return this._pq.peek();
     };
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     Heap.prototype.peekLast = function () {
         return this._pq.leaf();
     };
     /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.add = function (element, priority) {
-        if (typeof element === 'number') {
-            priority = element;
+    Heap.prototype.add = function (val, priority) {
+        if (typeof val === 'number') {
+            priority = val;
         }
         else {
             if (priority === undefined) {
@@ -111,16 +141,16 @@ var Heap = /** @class */ (function () {
         if (priority && Number.isNaN(+priority)) {
             throw new Error('.add expects a numeric priority');
         }
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
+        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(val))) {
             throw new Error('.add expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
-        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.add({ priority: _priority, element: element });
+        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(val);
+        this._pq.add(new HeapItem(_priority, val));
         return this;
     };
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
     Heap.prototype.poll = function () {
@@ -130,9 +160,24 @@ var Heap = /** @class */ (function () {
         }
         return top;
     };
+    /**
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
+     */
+    Heap.prototype.has = function (node) {
+        if (node instanceof (HeapItem)) {
+            return this.getPq().getNodes().includes(node);
+        }
+        else {
+            return this.getPq().getNodes().findIndex(function (item) {
+                return item.val === node;
+            }) !== -1;
+        }
+    };
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     Heap.prototype.toArray = function () {
         return this._pq.toArray();

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

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MaxHeap
  * @extends Heap
  */
-export declare class MaxHeap<T> extends Heap<T> {
+export declare class MaxHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.

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

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MinHeap
  * @extends Heap
  */
-export declare class MinHeap<T> extends Heap<T> {
+export declare class MinHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem

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

@@ -4,6 +4,7 @@ export * from './stack';
 export * from './queue';
 export * from './graph';
 export * from './binary-tree';
+export * from './tree';
 export * from './heap';
 export * from './priority-queue';
 export * from './matrix';

package/dist/data-structures/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./stack"), exports);
 __exportStar(require("./queue"), exports);
 __exportStar(require("./graph"), exports);
 __exportStar(require("./binary-tree"), exports);
+__exportStar(require("./tree"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);

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

@@ -8,9 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MaxPriorityQueue<T = number> extends PriorityQueue<T> {
-    /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
-     */
-    constructor(options?: PriorityQueueOptions<T>);
+    constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
+    constructor(options: PriorityQueueOptions<T>);
+    static heapify<T extends number>(options?: Omit<PriorityQueueOptions<T>, 'comparator'>): MaxPriorityQueue<T>;
+    static heapify<T>(options: PriorityQueueOptions<T>): MaxPriorityQueue<T>;
 }

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

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
 /**
@@ -27,17 +38,30 @@ var priority_queue_1 = require("./priority-queue");
 var MaxPriorityQueue = /** @class */ (function (_super) {
     __extends(MaxPriorityQueue, _super);
     /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
+     * The constructor initializes a priority queue with an optional comparator function.
+     * @param [options] - The `options` parameter is an optional object that can contain various properties to configure
+     * the priority queue.
      */
     function MaxPriorityQueue(options) {
-        return _super.call(this, {
-            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+        return _super.call(this, __assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
                 var aKey = a, bKey = b;
                 return bKey - aKey;
-            }
-        }) || this;
+            } })) || this;
     }
+    /**
+     * The function `heapify` creates a max priority queue from the given options and returns it.
+     * @param options - The `options` parameter is an object that contains configuration options for creating a priority
+     * queue. It can have the following properties:
+     * @returns a MaxPriorityQueue object.
+     */
+    MaxPriorityQueue.heapify = function (options) {
+        var maxPQ = new MaxPriorityQueue(__assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
+                return bKey - aKey;
+            } }));
+        maxPQ._fix();
+        return maxPQ;
+    };
     return MaxPriorityQueue;
 }(priority_queue_1.PriorityQueue));
 exports.MaxPriorityQueue = MaxPriorityQueue;

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

@@ -8,9 +8,8 @@
 import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../types';
 export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
-    /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
-     */
-    constructor(options?: PriorityQueueOptions<T>);
+    constructor(options?: Omit<PriorityQueueOptions<number>, 'comparator'>);
+    constructor(options: PriorityQueueOptions<T>);
+    static heapify<T extends number>(options?: Omit<PriorityQueueOptions<T>, 'comparator'>): MinPriorityQueue<T>;
+    static heapify<T>(options: PriorityQueueOptions<T>): MinPriorityQueue<T>;
 }

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

@@ -14,6 +14,17 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+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);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 /**
@@ -27,17 +38,31 @@ var priority_queue_1 = require("./priority-queue");
 var MinPriorityQueue = /** @class */ (function (_super) {
     __extends(MinPriorityQueue, _super);
     /**
-     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
-     * @param [options] - An optional object that contains the following properties:
+     * The constructor initializes a priority queue with an optional comparator function.
+     * @param [options] - The `options` parameter is an optional object that can contain various configuration options for
+     * the `PriorityQueue` constructor.
      */
     function MinPriorityQueue(options) {
-        return _super.call(this, {
-            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+        return _super.call(this, __assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
                 var aKey = a, bKey = b;
                 return aKey - bKey;
-            }
-        }) || this;
+            } })) || this;
     }
+    /**
+     * The function `heapify` creates a new MinPriorityQueue instance and sets the comparator function based on the options
+     * provided, and then fixes the heap structure of the queue.
+     * @param options - The `options` parameter is an object that contains configuration options for creating a priority
+     * queue. It can have the following properties:
+     * @returns a MinPriorityQueue object.
+     */
+    MinPriorityQueue.heapify = function (options) {
+        var minPQ = new MinPriorityQueue(__assign(__assign({}, options), { comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
+                return aKey - bKey;
+            } }));
+        minPQ._fix();
+        return minPQ;
+    };
     return MinPriorityQueue;
 }(priority_queue_1.PriorityQueue));
 exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -43,6 +43,13 @@ export declare class PriorityQueue<T = number> {
      * that needs to be added to the heap.
      */
     add(node: T): void;
+    /**
+     * The "has" function checks if a given node is present in the list of nodes.
+     * @param {T} node - The parameter `node` is of type `T`, which means it can be any type. It represents the node that
+     * we want to check if it exists in the `nodes` array.
+     * @returns a boolean value indicating whether the given node is included in the array of nodes.
+     */
+    has(node: T): boolean;
     /**
      * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
      * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
@@ -89,8 +96,12 @@ export declare class PriorityQueue<T = number> {
      */
     isValid(): boolean;
     /**
-     * The function sorts the elements in a data structure and returns them in ascending order.
-     * @returns The `sort()` function is returning an array of type `T[]`.
+     * Plan to support sorting of duplicate elements.
+     */
+    /**
+     * The function sorts the elements in a data structure and returns them in an array.
+     * Plan to support sorting of duplicate elements.
+     * @returns The `sort()` method is returning an array of type `T[]`.
      */
     sort(): T[];
     /**

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

@@ -51,9 +51,9 @@ var PriorityQueue = /** @class */ (function () {
         };
         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) {
+        if (nodes && Array.isArray(nodes) && nodes.length > 0) {
             // TODO support distinct
-            this._nodes = Array.isArray(nodes) ? __spreadArray([], __read(nodes), false) : [];
+            this._nodes = __spreadArray([], __read(nodes), false);
             isFix && this._fix();
         }
     }
@@ -94,7 +94,7 @@ var PriorityQueue = /** @class */ (function () {
      * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
      */
     PriorityQueue.isPriorityQueueified = function (options) {
-        return new PriorityQueue(__assign(__assign({}, options), { isFix: true })).isValid();
+        return new PriorityQueue(__assign(__assign({}, options), { isFix: false })).isValid();
     };
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
@@ -111,6 +111,15 @@ var PriorityQueue = /** @class */ (function () {
         this.nodes.push(node);
         this._heapifyUp(this.size - 1);
     };
+    /**
+     * The "has" function checks if a given node is present in the list of nodes.
+     * @param {T} node - The parameter `node` is of type `T`, which means it can be any type. It represents the node that
+     * we want to check if it exists in the `nodes` array.
+     * @returns a boolean value indicating whether the given node is included in the array of nodes.
+     */
+    PriorityQueue.prototype.has = function (node) {
+        return this.nodes.includes(node);
+    };
     /**
      * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
      * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
@@ -182,31 +191,28 @@ var PriorityQueue = /** @class */ (function () {
      * @returns The function `isValid()` returns a boolean value.
      */
     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);
+        for (var i = 0; i < this.nodes.length; i++) {
+            var leftChildIndex = this._getLeft(i);
+            var rightChildIndex = this._getRight(i);
+            if (this._isValidIndex(leftChildIndex) && !this._compare(leftChildIndex, i)) {
+                return false;
             }
-            if (_this._getRight(parentIndex) !== -1) {
-                var rightChildIndex = (parentIndex * 2) + 2;
-                if (!_this._compare(parentIndex, rightChildIndex))
-                    return false;
-                isValidRight = isValidRecursive(rightChildIndex);
+            if (this._isValidIndex(rightChildIndex) && !this._compare(rightChildIndex, i)) {
+                return false;
             }
-            return isValidLeft && isValidRight;
-        };
-        return isValidRecursive(0);
+        }
+        return true;
     };
     /**
-     * The function sorts the elements in a data structure and returns them in ascending order.
-     * @returns The `sort()` function is returning an array of type `T[]`.
+     * Plan to support sorting of duplicate elements.
+     */
+    /**
+     * The function sorts the elements in a data structure and returns them in an array.
+     * Plan to support sorting of duplicate elements.
+     * @returns The `sort()` method is returning an array of type `T[]`.
      */
     PriorityQueue.prototype.sort = function () {
+        // TODO Plan to support sorting of duplicate elements.
         var visitedNode = [];
         while (this.size !== 0) {
             var top = this.poll();

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

@@ -0,0 +1 @@
+export * from './tree';

package/dist/data-structures/tree/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("./tree"), exports);