data-structure-typed 1.19.4 → 1.19.6

package/README.md

@@ -1,31 +1,27 @@
 # What
 
 ## Brief
-Javascript & TypeScript Data Structure Library. 
+Javascript & TypeScript Data Structure collections. 
 
-Binary Tree, Binary Search Tree (BST), AVL Tree, Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Linked List, Singly Linked List, Doubly Linked List, Queue, Object Deque, Array Deque, Stack, Hash, Coordinate Set, Coordinate Map, Heap, Priority Queue, Max Priority Queue, Min Priority Queue, Trie
+## Algorithms 
 
-## Algorithms list only a few out, you can discover more in API docs
-
-DFS, DFSIterative, BFS, morris, Bellman-Ford Algorithm, Dijkstra's Algorithm, Floyd-Warshall Algorithm, Tarjan's Algorithm
+DFS, DFSIterative, BFS, morris, Bellman-Ford Algorithm, Dijkstra's Algorithm, Floyd-Warshall Algorithm, Tarjan's Algorithm. Listed only a few out, you can discover more in API docs
 
 ## Code design
 By strictly adhering to object-oriented design (BinaryTree -> BST -> AVLTree -> TreeMultiset), you can seamlessly inherit the existing data structures to implement the customized ones you need. Object-oriented design stands as the optimal approach to data structure design.
 
 # How
-
+### npm
+```bash
+npm install data-structure-typed
+```
 ## install
 ### yarn
-
 ```bash
 yarn add data-structure-typed
 ```
 
-### npm
 
-```bash
-npm install data-structure-typed
-```
 
 ### Binary Search Tree (BST) snippet
 

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -72,7 +72,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
     abstract edgesOf(vertexOrId: V | VertexId): E[];
     abstract getNeighbors(vertexOrId: V | VertexId): V[];
     abstract getEndsOfEdge(edge: E): [V, V] | null;
-    protected abstract _addEdgeOnly(edge: E): boolean;
     /**
      * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
      * @param {VertexId} vertexId - The `vertexId` parameter is the identifier of the vertex that you want to retrieve from
@@ -220,25 +219,6 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
      * @returns The function `dijkstra` returns an object of type `DijkstraResult<V>`.
      */
     dijkstra(src: V | VertexId, dest?: V | VertexId | null, getMinDist?: boolean, genPaths?: boolean): DijkstraResult<V>;
-    /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * /
-
-     /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-     */
-    /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-     */
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
@@ -268,6 +248,25 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         min: number;
         minPath: V[];
     };
+    /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * /
+
+     /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     */
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     */
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
+     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -325,6 +324,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any>, E ext
         SCCs: Map<number, V[]>;
         cycles: Map<number, V[]>;
     };
+    protected abstract _addEdgeOnly(edge: E): boolean;
     protected _addVertexOnly(newVertex: V): boolean;
     protected _getVertex(vertexOrId: VertexId | V): V | null;
     protected _getVertexId(vertexOrId: V | VertexId): VertexId;

package/dist/data-structures/graph/abstract-graph.js

@@ -600,25 +600,6 @@ class AbstractGraph {
         }
         return { distMap, preMap, seen, paths, minDist, minPath };
     }
-    /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * /
-
-     /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-     */
-    /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-     */
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
@@ -725,6 +706,25 @@ class AbstractGraph {
         }
         return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
     }
+    /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * /
+
+     /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     */
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     */
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
+     */
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs

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

@@ -44,16 +44,12 @@ export declare abstract class Heap<T = number> {
      * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     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 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 val with the lowest priority in the queue
-     */
-    peekLast(): HeapItem<T> | null;
+    peek(isItem?: undefined): T | undefined;
+    peek(isItem: false): T | undefined;
+    peek(isItem: true): HeapItem<T> | null;
+    peekLast(isItem?: undefined): T | undefined;
+    peekLast(isItem: false): T | undefined;
+    peekLast(isItem: true): HeapItem<T> | null;
     /**
      * 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
@@ -64,23 +60,19 @@ export declare abstract class Heap<T = number> {
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    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 val with the highest priority in the queue
-     * @returns either a HeapItem<T> object or null.
-     */
-    poll(): HeapItem<T> | null;
+    add(priority: number, val?: T): Heap<T>;
+    poll(isItem?: undefined): T | undefined;
+    poll(isItem: false): T | undefined;
+    poll(isItem: true): 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 vals
-     */
-    toArray(): HeapItem<T>[];
+    toArray(isItem?: undefined): (T | undefined)[];
+    toArray(isItem: false): (T | undefined)[];
+    toArray(isItem: true): (HeapItem<T> | null)[];
     /**
      * The clear function clears the priority queue.
      */

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

@@ -69,15 +69,19 @@ class Heap {
      * 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 val with the highest priority in the queue
      */
-    peek() {
-        return this._pq.peek();
+    peek(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const peeked = this._pq.peek();
+        return isItem ? peeked : peeked === null || peeked === void 0 ? void 0 : peeked.val;
     }
     /**
      * The `peekLast` function returns the last item in the heap.
      * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
-    peekLast() {
-        return this._pq.leaf();
+    peekLast(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const leafItem = this._pq.leaf();
+        return isItem ? leafItem : leafItem === null || leafItem === void 0 ? void 0 : leafItem.val;
     }
     /**
      * The `add` function adds an val to a priority queue with an optional priority value.
@@ -89,36 +93,22 @@ class Heap {
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    add(val, priority) {
-        if (typeof val === 'number') {
-            priority = val;
-        }
-        else {
-            if (priority === undefined) {
-                throw new Error('.add expects a numeric priority');
-            }
-        }
-        if (priority && Number.isNaN(+priority)) {
-            throw new Error('.add expects a numeric priority');
-        }
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityExtractor(val))) {
-            throw new Error('.add expects a numeric priority '
-                + 'or a constructor callback that returns a number');
-        }
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityExtractor(val);
-        this._pq.add(new HeapItem(_priority, val));
+    add(priority, val) {
+        val = (val === undefined) ? priority : 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 val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
-    poll() {
+    poll(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
         const top = this._pq.poll();
         if (!top) {
             return null;
         }
-        return top;
+        return isItem ? top : top.val;
     }
     /**
      * The function checks if a given node or value exists in the priority queue.
@@ -139,8 +129,10 @@ class Heap {
      * The `toArray` function returns an array of `HeapItem<T>` objects.
      * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
-    toArray() {
-        return this._pq.toArray();
+    toArray(isItem) {
+        isItem = isItem !== null && isItem !== void 0 ? isItem : false;
+        const itemArray = this._pq.toArray();
+        return isItem ? itemArray : itemArray.map(item => item.val);
     }
     /**
      * The clear function clears the priority queue.

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

@@ -95,7 +95,7 @@ export declare class PriorityQueue<T = number> {
      */
     isValid(): boolean;
     /**
-     * Plan to support sorting of duplicate elements.
+     * O(n log n), In scenarios with smaller data sizes, heap sort is generally expected to be slower than QuickSort or MergeSort.
      */
     /**
      * The function sorts the elements in a data structure and returns them in an array.

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

@@ -157,7 +157,7 @@ class PriorityQueue {
         return true;
     }
     /**
-     * Plan to support sorting of duplicate elements.
+     * O(n log n), In scenarios with smaller data sizes, heap sort is generally expected to be slower than QuickSort or MergeSort.
      */
     /**
      * The function sorts the elements in a data structure and returns them in an array.
@@ -165,7 +165,6 @@ class PriorityQueue {
      * @returns The `sort()` method is returning an array of type `T[]`.
      */
     sort() {
-        // TODO Plan to support sorting of duplicate elements.
         const visitedNode = [];
         while (this.size !== 0) {
             const top = this.poll();

package/jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
     preset: 'ts-jest',
     testEnvironment: 'node',
-    testMatch: ['<rootDir>/tests/**/*.test.ts'],
+    testMatch: ['<rootDir>/tests/**/*.test.ts', '<rootDir>/tests/**/*.test.js'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.19.4",
+  "version": "1.19.6",
   "description": "Javascript & TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
@@ -65,7 +65,9 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "bst-typed": "^1.19.0",
+    "avl-tree-typed": "^1.19.6",
+    "bst-typed": "^1.19.6",
+    "heap-typed": "^1.19.6",
     "zod": "^3.22.2"
   }
 }

package/src/data-structures/graph/abstract-graph.ts

@@ -129,6 +129,7 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
     abstract createEdge(srcOrV1: VertexId | string, destOrV2: VertexId | string, weight?: number, val?: E): E;
 
     abstract removeEdge(edge: E): E | null;
+
     abstract getEdge(srcOrId: V | VertexId, destOrId: V | VertexId): E | null;
 
     abstract degreeOf(vertexOrId: V | VertexId): number;
@@ -141,8 +142,6 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
 
     abstract getEndsOfEdge(edge: E): [V, V] | null;
 
-    protected abstract _addEdgeOnly(edge: E): boolean;
-
     /**
      * The function "getVertex" returns the vertex with the specified ID or null if it doesn't exist.
      * @param {VertexId} vertexId - The `vertexId` parameter is the identifier of the vertex that you want to retrieve from
@@ -165,7 +164,9 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
     }
 
     addVertex(vertex: V): boolean
+
     addVertex(id: VertexId, val?: V['val']): boolean
+
     addVertex(idOrVertex: VertexId | V, val?: V['val']): boolean {
         if (idOrVertex instanceof AbstractVertex) {
             return this._addVertexOnly(idOrVertex);
@@ -256,7 +257,6 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
         }
     }
 
-
     /**
      * The function `getAllPathsBetween` finds all paths between two vertices in a graph using depth-first search.
      * @param {V | VertexId} v1 - The parameter `v1` represents either a vertex object (`V`) or a vertex ID (`VertexId`).
@@ -691,29 +691,6 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
         return {distMap, preMap, seen, paths, minDist, minPath};
     }
 
-    /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * /
-
-     /**
-     * Dijkstra algorithm time: O(logVE) space: O(V + E)
-     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
-     */
-
-
-    /**
-     * BellmanFord time:O(VE) space:O(V)
-     * one to rest pairs
-     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
-     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
-     */
-
-    /**
-     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
-     * all pairs
-     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
-     */
-
     /**
      * BellmanFord time:O(VE) space:O(V)
      * one to rest pairs
@@ -823,6 +800,29 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
         return {hasNegativeCycle, distMap, preMap, paths, min, minPath};
     }
 
+    /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * /
+
+     /**
+     * Dijkstra algorithm time: O(logVE) space: O(V + E)
+     * Dijkstra's algorithm is used to find the shortest paths from a source node to all other nodes in a graph. Its basic idea is to repeatedly choose the node closest to the source node and update the distances of other nodes using this node as an intermediary. Dijkstra's algorithm requires that the edge weights in the graph are non-negative.
+     */
+
+
+    /**
+     * BellmanFord time:O(VE) space:O(V)
+     * one to rest pairs
+     * The Bellman-Ford algorithm is also used to find the shortest paths from a source node to all other nodes in a graph. Unlike Dijkstra's algorithm, it can handle edge weights that are negative. Its basic idea involves iterative relaxation of all edges for several rounds to gradually approximate the shortest paths. Due to its ability to handle negative-weight edges, the Bellman-Ford algorithm is more flexible in some scenarios.
+     * The `bellmanFord` function implements the Bellman-Ford algorithm to find the shortest path from a source vertex to
+     */
+
+    /**
+     * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
+     * all pairs
+     * The Floyd-Warshall algorithm is used to find the shortest paths between all pairs of nodes in a graph. It employs dynamic programming to compute the shortest paths from any node to any other node. The Floyd-Warshall algorithm's advantage lies in its ability to handle graphs with negative-weight edges, and it can simultaneously compute shortest paths between any two nodes.
+     */
+
     /**
      * Floyd algorithm time: O(V^3) space: O(V^2), not support graph with negative weight cycle
      * all pairs
@@ -1007,6 +1007,7 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
         return {dfnMap, lowMap, bridges, articulationPoints, SCCs, cycles};
     }
 
+    protected abstract _addEdgeOnly(edge: E): boolean;
 
     protected _addVertexOnly(newVertex: V): boolean {
         if (this.hasVertex(newVertex)) {

package/src/data-structures/heap/heap.ts

@@ -88,20 +88,30 @@ export abstract class Heap<T = number> {
         return this._pq.size < 1;
     }
 
+    peek(isItem?: undefined): T | undefined;
+    peek(isItem: false): T | undefined;
+    peek(isItem: true): HeapItem<T> | null;
     /**
      * 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 val with the highest priority in the queue
      */
-    peek(): HeapItem<T> | null {
-        return this._pq.peek();
+    peek(isItem?: boolean): HeapItem<T> | null | T | undefined {
+        isItem = isItem ?? false;
+        const peeked = this._pq.peek();
+        return isItem ? peeked : peeked?.val;
     }
 
+    peekLast(isItem?: undefined): T | undefined;
+    peekLast(isItem: false): T | undefined;
+    peekLast(isItem: true): 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 val with the lowest priority in the queue
      */
-    peekLast(): HeapItem<T> | null {
-        return this._pq.leaf();
+    peekLast(isItem?: boolean): HeapItem<T> | null | T | undefined {
+        isItem = isItem ?? false;
+        const leafItem = this._pq.leaf();
+        return isItem ? leafItem : leafItem?.val;
     }
 
     /**
@@ -114,41 +124,26 @@ export abstract class Heap<T = number> {
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    add(val: T, priority?: number): Heap<T> {
-        if (typeof val === 'number') {
-            priority = val;
-        } else {
-            if (priority === undefined) {
-                throw new Error('.add expects a numeric priority');
-            }
-        }
-
-        if (priority && Number.isNaN(+priority)) {
-            throw new Error('.add expects a numeric priority');
-        }
-
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityExtractor(val))) {
-            throw new Error(
-                '.add expects a numeric priority '
-                + 'or a constructor callback that returns a number'
-            );
-        }
-
-        const _priority = !Number.isNaN(+priority) ? priority : this._priorityExtractor(val);
-        this._pq.add(new HeapItem<T>(_priority, val));
+    add(priority: number, val?: T,): Heap<T> {
+        val = (val === undefined) ? priority as T : val;
+        this._pq.add(new HeapItem<T>(priority, val));
         return this;
     }
 
+    poll(isItem?: undefined): T | undefined;
+    poll(isItem: false): T | undefined;
+    poll(isItem: true): HeapItem<T> | null;
     /**
      * 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 {
+    poll(isItem?: boolean): HeapItem<T> | null | T | undefined {
+        isItem = isItem ?? false;
         const top = this._pq.poll();
         if (!top) {
             return null;
         }
-        return top;
+        return isItem ? top : top.val;
     }
 
     /**
@@ -166,12 +161,17 @@ export abstract class Heap<T = number> {
         }
     }
 
+    toArray(isItem?: undefined): (T | undefined)[];
+    toArray(isItem: false): (T | undefined)[];
+    toArray(isItem: true): (HeapItem<T> | null)[];
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
      * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
-    toArray(): HeapItem<T>[] {
-        return this._pq.toArray();
+    toArray(isItem?: boolean): (HeapItem<T> | null | T | undefined)[] {
+        isItem = isItem ?? false;
+        const itemArray = this._pq.toArray();
+        return isItem ? itemArray : itemArray.map(item => item.val);
     }
 
     /**

package/src/data-structures/priority-queue/priority-queue.ts

@@ -174,15 +174,15 @@ export class PriorityQueue<T = number> {
     }
 
     /**
-     * Plan to support sorting of duplicate elements.
+     * O(n log n), In scenarios with smaller data sizes, heap sort is generally expected to be slower than QuickSort or MergeSort.
      */
+
     /**
      * 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[] {
-        // TODO Plan to support sorting of duplicate elements.
         const visitedNode: T[] = [];
         while (this.size !== 0) {
             const top = this.poll();