@raikuxq/alg-ds 2.0.0 → 3.0.0

package/README.md

@@ -86,23 +86,23 @@ Extends [ILinearStorage](src/app/types/ILinearStorage.ts) interface.
 Extends [ILinearStorageRA](src/app/types/ILinearStorageRA.ts) and [IConvertableToArray](src/app/types/IConvertableToArray.ts) interface.
 
 ### Implementation
-[AbstractLinkedList](src/app/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedList.ts) — Common logic for both single and double linked lists.
+[AbstractLinkedList](src/app/data-structures/LinkedList/core/AbstractLinkedList/AbstractLinkedList.ts) — Common logic for both single and double linked lists.
 Implements [ILinearStorageRA](src/app/types/ILinearStorageRA.ts) interface.
 
-[SingleLinkedList](src/app/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.ts) 
+[SingleLinkedList](src/app/data-structures/LinkedList/core/SingleLinkedList/SingleLinkedList.ts) 
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list.test.ts)
 — Extends abstract linked list with implementation of one-way linking. 
 
-[DoubleLinkedList](src/app/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList.ts) 
+[DoubleLinkedList](src/app/data-structures/LinkedList/core/DoubleLinkedList/DoubleLinkedList.ts) 
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list.test.ts)
 — Extends abstract linked list with implementation of two-way linking.
 
-[IterableSingleLinkedList](src/app/data-structures/LinkedList/SingleLinkedList/IterableSingleLinkedList.ts)
+[IterableSingleLinkedList](src/app/data-structures/LinkedList/core/SingleLinkedList/IterableSingleLinkedList.ts)
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list-iterable.test.ts)
 — Extends single linked list with iterator implementation.
 Implements [IIterable](src/app/types/IIterable.ts) interface.
 
-[IterableDoubleLinkedList](src/app/data-structures/LinkedList/DoubleLinkedList/IterableDoubleLinkedList.ts)
+[IterableDoubleLinkedList](src/app/data-structures/LinkedList/core/DoubleLinkedList/IterableDoubleLinkedList.ts)
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list-iterable.test.ts)
 — Extends double linked list with implementation of two-way linking.
 Implements [IBiDirectIterable](src/app/types/IBiDirectIterable.ts) interface.
@@ -132,52 +132,52 @@ Implements [IBiDirectIterable](src/app/types/IBiDirectIterable.ts) interface.
 [IGraphIterationStrategy](src/app/types/IGraphIterationStrategy.ts) — Iteration strategies which are used in shortest-path, has-path.
 
 ### Implementation
-[GraphEdge](src/app/data-structures/Graph/GraphEdge.ts) — Contains from/to links and edge weight.
+[GraphEdge](src/app/data-structures/Graph/core/GraphEdge.ts) — Contains from/to links and edge weight.
 
-[AbstractGraph](src/app/data-structures/Graph/AbstractGraph.ts) — Common logic for both directed and undirected graphs.
+[AbstractGraph](src/app/data-structures/Graph/core/AbstractGraph.ts) — Common logic for both directed and undirected graphs.
 
 
-[DirectedGraph](src/app/data-structures/Graph/DirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
+[DirectedGraph](src/app/data-structures/Graph/core/DirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
 — In case of directed graph A->B and B->A edges are not the same.
 
-[UndirectedGraph](src/app/data-structures/Graph/UndirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
+[UndirectedGraph](src/app/data-structures/Graph/core/UndirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
 — In case of undirected graph A->B and B->A are equal.
 
 
 ### Graph Iterators
 
-[BreadthFirstSearchIterator](src/app/algorithms/graph/iterator/GraphIteratorBFS.ts) 
+[BreadthFirstSearchIterator](src/app/data-structures/Graph/iterator/GraphIteratorBFS.ts) 
 — Traversal method for unweighted graphs, built on queue.
 
-[DepthFirstSearchIterator](src/app/algorithms/graph/iterator/GraphIteratorDFS.ts)
+[DepthFirstSearchIterator](src/app/data-structures/Graph/iterator/GraphIteratorDFS.ts)
 — Traversal method for unweighted graphs, built on stack.
 
-[DijkstraMethodIterator](src/app/algorithms/graph/iterator/GraphIteratorDijkstra.ts)
+[DijkstraMethodIterator](src/app/data-structures/Graph/iterator/GraphIteratorDijkstra.ts)
 — Traversal method for weighted graphs, built on finding the minimal cost.
 
 
 ### Graph Presenter
-[presenter-adjacency-lists](src/app/algorithms/graph/presenter/presenterAdjacencyLists.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.lists.test.ts)] 
+[presenter-adjacency-lists](src/app/data-structures/Graph/presenter/presenterAdjacencyLists.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.lists.test.ts)] 
 — Representation of graph as an adjacency list (using Map).
 
-[presenter-adjacency-matrix](src/app/algorithms/graph/presenter/presenterAdjacencyMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.matrix.test.ts)]
+[presenter-adjacency-matrix](src/app/data-structures/Graph/presenter/presenterAdjacencyMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.matrix.test.ts)]
 — Representation of graph as an adjacency matrix (using Array N*N).
 
 
 ### Graph Searching
-[has-path (BFS/DFS)](src/app/algorithms/graph/searching/hasPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.has-path.test.ts)] 
+[has-path (BFS/DFS)](src/app/data-structures/Graph/searching/hasPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.has-path.test.ts)] 
 — Search for the existence of a path between two vertices.
 
-[shortest-path (BFS/Dijkstra)](src/app/algorithms/graph/searching/shortestPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.shortest-path.test.ts)] 
+[shortest-path (BFS/Dijkstra)](src/app/data-structures/Graph/searching/shortestPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.shortest-path.test.ts)] 
 — Search for one of several shortest paths between two vertices.
 
 ### Graph Creators
-[create-graph-from-matrix](src/app/data-structures/Graph/_helpers/createGraphFromMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.create-from-matrix.test.ts)] 
+[create-graph-from-matrix](src/app/data-structures/Graph/factories/createGraphFromMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.create-from-matrix.test.ts)] 
 — Convert a matrix N*N into a graph instance.
 
 
 ### Graph Transposing
-[transpose-directed-graph](src/app/algorithms/graph/transposing/transposeDirectedGraph.ts)  [ [ tests ](test/unit/data-structures/graph/graph.transpose.test.ts)]
+[transpose-directed-graph](src/app/data-structures/Graph/transposing/transposeDirectedGraph.ts)  [ [ tests ](test/unit/data-structures/graph/graph.transpose.test.ts)]
 — Transpose a directed graph (undirected graphs are symmetrical already).
 
 
@@ -187,23 +187,23 @@ Implements [IBiDirectIterable](src/app/types/IBiDirectIterable.ts) interface.
 
 ### Implementation
 
-[AbstractBinaryNode](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.ts) — Contains left/right/parent links and node data.
+[AbstractBinaryNode](src/app/data-structures/BinaryTree/core/AbstractBinaryTree/AbstractBinaryNode.ts) — Contains left/right/parent links and node data.
 
-[AbstractBinaryTree](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts) — Common logic for all types of binary trees.
+[AbstractBinaryTree](src/app/data-structures/BinaryTree/core/AbstractBinaryTree/AbstractBinaryTree.ts) — Common logic for all types of binary trees.
 
   
-[BinarySearchNode](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts) — Same as abstract binary node.
+[BinarySearchNode](src/app/data-structures/BinaryTree/core/BinarySearchTree/BinarySearchNode.ts) — Same as abstract binary node.
 
-[BinarySearchTree](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts) — Implementation of unbalanced binary search tree. 
+[BinarySearchTree](src/app/data-structures/BinaryTree/core/BinarySearchTree/BinarySearchTree.ts) — Implementation of unbalanced binary search tree. 
 Each node in left subtree is smaller and each node in right subtree is larger than the node data. 
-Extends [AbstractSearchTree](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts).
+Extends [AbstractSearchTree](src/app/data-structures/BinaryTree/core/AbstractBinaryTree/AbstractBinaryTree.ts).
 
 
 
-[RandBinarySearchNode](src/app/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.ts) — Have a rank attribute. 
-Extends [BinarySearchNode](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts).
+[RandBinarySearchNode](src/app/data-structures/BinaryTree/core/RandBinarySearchTree/RandBinarySearchNode.ts) — Have a rank attribute. 
+Extends [BinarySearchNode](src/app/data-structures/BinaryTree/core/BinarySearchTree/BinarySearchNode.ts).
 
-[RandBinarySearchTree](src/app/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree.ts) 
+[RandBinarySearchTree](src/app/data-structures/BinaryTree/core/RandBinarySearchTree/RandBinarySearchTree.ts) 
 — Implementation of randomized binary search tree, which gives expected log(N) height. 
 INSERTION have a 1/N+1 probability of inserting into root. 
-Extends [BinarySearchTree](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts).
+Extends [BinarySearchTree](src/app/data-structures/BinaryTree/core/BinarySearchTree/BinarySearchTree.ts).

package/lib/index.d.ts

@@ -1,20 +1,22 @@
 // Generated by dts-bundle-generator v9.5.1
 
+export declare const EDGE_EXISTS_STATE = 1;
+export declare const EDGE_NOT_EXISTS_STATE = 0;
 export type FnToMemoize<Key, Value> = (...args: Array<Key>) => Value;
 /**
- * Time complexity: O(n!)
+ * Time complexity: O(n)
  */
 export declare const factorial: (x: number) => number;
 /**
- * Time complexity: O(n) - due to caching
+ * Time complexity: O(n) for the first call, O(1) for cached calls
  */
 export declare const memoizedFactorial: FnToMemoize<number, number>;
 /**
- * Time complexity: O(n!)
+ * Time complexity: O(2^n) - exponential without memoization
  */
 export declare const fibonacci: (n: number) => number;
 /**
- * Time complexity: O(n) - due to caching
+ * Time complexity: O(n) - linear due to caching
  */
 export declare const memoizedFibonacci: FnToMemoize<number, number>;
 /**
@@ -28,7 +30,7 @@ export type TypeArrayMatrix = Array<Array<number>>;
  * @throws {IllegalArgumentException} when array is not a matrix
  */
 export declare const transposeMatrix: (matrix: TypeArrayMatrix) => TypeArrayMatrix;
-export interface IGraph<T> {
+export interface IGraph<T> extends Iterable<T> {
 	weight(): number;
 	vertices(): Array<T>;
 	verticesCount(): number;
@@ -67,18 +69,6 @@ export interface IGraphIterator<T> extends IIterator<T> {
 	 */
 	initIterator(from: T): void;
 }
-export interface IGraphIterationStrategy<T> {
-	createIterator(graph: IGraph<T>): IGraphIterator<T>;
-}
-export declare class BFSIterationStrategy<T> implements IGraphIterationStrategy<T> {
-	createIterator(graph: IGraph<T>): IGraphIterator<T>;
-}
-export declare class DFSIterationStrategy<T> implements IGraphIterationStrategy<T> {
-	createIterator(graph: IGraph<T>): IGraphIterator<T>;
-}
-export declare class DijkstraIterationStrategy<T> implements IGraphIterationStrategy<T> {
-	createIterator(graph: IGraph<T>): IGraphIterator<T>;
-}
 declare abstract class AbstractGraphIterator<T> implements IGraphIterator<T> {
 	protected readonly graph: IGraph<T>;
 	protected readonly visited: Map<T, boolean>;
@@ -169,18 +159,15 @@ export declare class GraphIteratorDFS<T> extends AbstractGraphIterator<T> {
 	nextImpl(): T;
 }
 /**
- * Dijkstra method graph traversal
+ * Dijkstra method graph traversal using a Priority Queue.
  */
 export declare class GraphIteratorDijkstra<T> extends AbstractGraphIterator<T> {
 	private readonly costs;
+	private readonly queue;
 	/**
 	 * @inheritDoc
 	 */
 	constructor(graph: IGraph<T>);
-	/**
-	 * Get not visited vertex with minimal cost
-	 */
-	private getClosestNotVisited;
 	/**
 	 * @inheritDoc
 	 */
@@ -197,21 +184,44 @@ export declare class GraphIteratorDijkstra<T> extends AbstractGraphIterator<T> {
 	 * @inheritDoc
 	 */
 	nextImpl(): T;
+	/**
+	 * Removes stale entries from the queue top.
+	 */
+	private refreshQueue;
+}
+declare enum EnumGraphTraversalType {
+	BFS = "Breadth first traversal",
+	DFS = "Deep first traversal",
+	DIJKSTRA = "Dijkstra traversal"
 }
+/**
+ * Creates a graph iterator based on the specified traversal mode.
+ */
+export declare const createGraphIterator: <T>(graph: IGraph<T>, mode: EnumGraphTraversalType) => IGraphIterator<T>;
 /**
  * Check if graph has a path between two vertices
  * @throws {IsNotFoundException} when start vertex was not found
  * @throws {IsNotFoundException} when end vertex was not found
  * @throws {IllegalStateException} when there is no path between two vertices
  */
-export declare const hasPath: <T>(graph: IGraph<T>, from: T, to: T, strategy: IGraphIterationStrategy<T>) => boolean;
+export declare const hasPath: <T>({ graph, traversalType, from, to, }: {
+	graph: IGraph<T>;
+	from: T;
+	to: T;
+	traversalType: EnumGraphTraversalType;
+}) => boolean;
 /**
  * Find the shortest path between two vertices
  * @throws {IsNotFoundException} when start vertex was not found
  * @throws {IsNotFoundException} when end vertex was not found
  * @throws {IllegalStateException} when there is no path between two vertices
  */
-export declare const shortestPath: <T>(graph: IGraph<T>, from: T, to: T, strategy: IGraphIterationStrategy<T>) => Array<T>;
+export declare const shortestPath: <T>({ graph, traversalType, from, to, }: {
+	graph: IGraph<T>;
+	from: T;
+	to: T;
+	traversalType: EnumGraphTraversalType;
+}) => Array<T>;
 /**
  * Get graph adjacency matrix N x N
  *
@@ -231,7 +241,7 @@ export declare const shortestPath: <T>(graph: IGraph<T>, from: T, to: T, strateg
  * @example
  *
  * Undirected graph:
- * - Bob [Maria]
+ * - Bob [Mariaэ
  * - Maria [Bob, John]
  * - John [Maria]
  *
@@ -260,15 +270,6 @@ export declare const presenterAdjacencyMatrix: <T>(graph: IGraph<T>) => TypeArra
  * - John [Maria]
  **/
 export declare const presenterAdjacencyLists: <T>(graph: IGraph<T>) => Map<T, Array<T>>;
-declare enum EnumGraphType {
-	DIRECTED = "DIRECTED",
-	UNDIRECTED = "UNDIRECTED"
-}
-declare enum EnumRandomGenerationFormat {
-	NUMBERS = "NUMBERS",
-	HASH = "HASH"
-}
-export declare const generateRandomGraph: (verticesCount: number, edgesCount: number, type?: EnumGraphType, format?: EnumRandomGenerationFormat) => IGraph<string>;
 declare enum EnumLinkedListType {
 	DOUBLE = "Double linked list",
 	SINGLE = "Single linked list"
@@ -300,7 +301,7 @@ export interface IConvertableToArray<T> {
 	pushFromArray(elements: Array<T>): void;
 	getAsArray(): Array<T>;
 }
-export interface ILinkedList<T> extends ILinearStorageRA<T>, IConvertableToArray<T> {
+export interface ILinkedList<T> extends ILinearStorageRA<T>, IConvertableToArray<T>, Iterable<T> {
 }
 export declare const createLinkedList: <T>(type: EnumLinkedListType, isIterable?: boolean, capacity?: number) => ILinkedList<T>;
 declare enum EnumBinarySearchTreeType {
@@ -327,6 +328,10 @@ export interface IBinaryTree<T> {
  * Returns binary tree by type
  */
 export declare const createBinaryTree: <T>(type: EnumBinarySearchTreeType) => IBinaryTree<T>;
+declare enum EnumGraphType {
+	DIRECTED = "DIRECTED",
+	UNDIRECTED = "UNDIRECTED"
+}
 /**
  * Returns graph by type
  */
@@ -335,8 +340,6 @@ export declare const createGraph: <T>(type: EnumGraphType) => IGraph<T>;
  * Creates a graph from N*N matrix that contains 1 in case of edge exists or 0 in case it does not
  */
 export declare const createGraphFromMatrix: <T>(matrix: TypeArrayMatrix, fieldsList: Array<T>, type: EnumGraphType) => IGraph<T>;
-export declare const EDGE_EXISTS_STATE = 1;
-export declare const EDGE_NOT_EXISTS_STATE = 0;
 /**
  * FIFO data structure
  */
@@ -386,204 +389,91 @@ export declare class Queue<T> implements ILinearStorage<T> {
 	 */
 	reverse(): void;
 }
-/**
- * LIFO data structure
- */
-export declare class Stack<T> implements ILinearStorage<T> {
-	private readonly _list;
-	/**
-	 * Create a stack instance
-	 */
+export declare class Stack<T> implements ILinearStorage<T>, Iterable<T> {
+	private readonly _items;
+	private readonly _capacity;
 	constructor(capacity?: number);
-	/**
-	 * Get stack top element
-	 * @throws {CollectionIsEmptyException} when list is empty
-	 */
+	length(): number;
+	isEmpty(): boolean;
+	isFull(): boolean;
 	peek(): T;
-	/**
-	 * Add element to stack head
-	 * @throws {CollectionIsFullException} when list is full
-	 */
 	push(item: T): void;
-	/**
-	 * Remove element from stack head
-	 * @throws {CollectionIsEmptyException} when list is empty
-	 */
 	pop(): T;
-	/**
-	 * Check if element exists in list
-	 */
 	has(item: T): boolean;
-	/**
-	 * Is stack empty
-	 */
-	isEmpty(): boolean;
-	/**
-	 * Is stack full
-	 */
-	isFull(): boolean;
-	/**
-	 * Remove all elements in stack
-	 */
 	clear(): void;
-	/**
-	 * Queue length
-	 */
-	length(): number;
-	/**
-	 * Reverse stack
-	 */
 	reverse(): void;
-}
-declare class GraphEdge<T> {
-	private readonly _fromVertex;
-	private readonly _toVertex;
-	private _weight;
-	/**
-	 * Create instance with linked "from" and "to" vertices
-	 */
-	constructor(fromVertex: T, toVertex: T, weight?: number);
-	get fromVertex(): T;
-	get toVertex(): T;
-	get weight(): number;
-	set weight(value: number);
-}
-declare abstract class AbstractGraph<T> {
-	protected _vertices: Map<T, Array<T>>;
-	protected _edges: Array<GraphEdge<T>>;
-	/**
-	 * Created empty instance
-	 */
-	protected constructor();
-	/**
-	 * Find edge by its from and to vertices
-	 */
-	protected abstract getEdgeByValue(from: T, to: T): GraphEdge<T>;
-	/**
-	 * Get vertices list in array format
-	 */
-	protected getVerticesArrayFormat(): Array<T>;
-	/**
-	 * Find vertex in vertices list by its data
-	 * @throws {IsNotFoundException} when vertex was not found
-	 */
-	protected tryFindVertex(data: T): T;
-	/**
-	 * Update edge weight between from and to vertices
-	 */
-	protected updateEdgeWeight(from: T, to: T, weight: number): void;
-	/**
-	 * Will remove all vertex relations with others vertices
-	 */
-	protected cascadeRemoveVertexRelations(vertexToRemove: T): void;
-	/**
-	 * Will remove all vertices edges with vertex to remove
-	 */
-	protected cascadeRemoveVertexEdges(vertexToRemove: T): void;
-	/**
-	 * Get sum of all graph edges
-	 */
-	weight(): number;
-	/**
-	 * Get array of vertices
-	 */
-	vertices(): Array<T>;
-	/**
-	 * Get vertices count
-	 */
-	verticesCount(): number;
-	/**
-	 * Get edges count
-	 */
-	edgesCount(): number;
-	/**
-	 * Add vertex
-	 * @throws {IsAlreadyExistsException} when vertex is already exists
-	 */
-	addVertex(data: T): this;
-	/**
-	 * Remove vertex
-	 * @throws {IsNotFoundException} when vertex is already does not exist
-	 */
-	removeVertex(data: T): this;
-	/**
-	 * Add edge between two vertices
-	 */
-	abstract addEdge(from: T, to: T, weight?: number): this;
-	/**
-	 * Remove edge between two vertices
-	 */
-	abstract removeEdge(from: T, to: T): this;
-	/**
-	 * Get vertex neighbors by its data
-	 */
-	getVertexNeighbors(data: T): Array<T>;
-	/**
-	 * Check if graph has vertex
-	 */
-	hasVertex(data: T): boolean;
-	/**
-	 * Check if graph has edge between from and to vertices
-	 */
-	hasEdge(from: T, to: T): boolean;
-	/**
-	 * Get edge weight between from and to vertices
-	 */
-	getEdgeWeight(from: T, to: T): number;
+	[Symbol.iterator](): Iterator<T>;
 }
 /**
- * Undirected graph - data structure where edges with same pair of vertices are equal
- * @example A-B is same as B-A
+ * A Priority Queue implementation based on a Min-Binary Heap.
+ * Lower priority numbers are dequeued first.
  */
-export declare class UndirectedGraph<T> extends AbstractGraph<T> {
-	/**
-	 * @inheritDoc
-	 */
+export declare class PriorityQueue<T> {
+	private readonly _heap;
 	constructor();
+	/** Number of elements in the queue. */
+	get size(): number;
+	/** Returns true if the queue is empty. */
+	isEmpty(): boolean;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
-	 */
-	protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
-	/**
-	 * @inheritDoc
+	 * Adds an element to the queue with a specific priority.
+	 * @param value The data to store.
+	 * @param priority The priority level (lower value = higher priority).
 	 */
-	hasEdge(from: T, to: T): boolean;
+	enqueue(value: T, priority: number): void;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
+	 * Removes and returns the element with the highest priority (lowest priority number).
+	 * @throws {CollectionIsEmptyException} If the queue is empty.
 	 */
-	addEdge(from: T, to: T, weight?: number): this;
+	dequeue(): T;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
+	 * Returns the highest priority element without removing it.
+	 * @throws {CollectionIsEmptyException} If the queue is empty.
 	 */
-	removeEdge(from: T, to: T): this;
+	peek(): T;
+	/** Clears all elements from the queue. */
+	clear(): void;
 }
 /**
- * Directed graph - data structure where edges with same pair of vertices are not equal
- * @example A-B is not the same as B-A
+ * A Binary Heap implementation supporting custom priority logic
  */
-export declare class DirectedGraph<T> extends AbstractGraph<T> {
+export declare class BinaryHeap<T> {
+	private readonly _heap;
+	private readonly _comparator;
 	/**
-	 * @inheritDoc
+	 * @param comparator Function to determine element priority
 	 */
-	constructor();
+	constructor(comparator?: (a: T, b: T) => number);
+	/** Current number of elements in the heap */
+	get size(): number;
+	/** Returns true if the heap contains no elements */
+	isEmpty(): boolean;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
+	 * Retrieves the root element without removing it
+	 * @throws {CollectionIsEmptyException} If the heap is empty.
 	 */
-	protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+	peek(): T;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
+	 * Adds a new value and restores heap properties
 	 */
-	addEdge(from: T, to: T, weight?: number): this;
+	insert(value: T): void;
 	/**
-	 * @inheritDoc
-	 * @throws {IsNotFoundException} when vertex was not found
-	 */
-	removeEdge(from: T, to: T): this;
+	 * Removes and returns the root element (minimum based on comparator)
+	 * @throws {CollectionIsEmptyException} If the heap is empty.
+	 */
+	extractMin(): T;
+	/** Default comparison for primitive types */
+	private defaultComparator;
+	private parentIndex;
+	private leftChildIndex;
+	private rightChildIndex;
+	private swap;
+	/** Moves an element up until heap properties are restored */
+	private bubbleUp;
+	/** Moves an element down until heap properties are restored */
+	private bubbleDown;
+	/** Returns an iterator over the underlying array */
+	[Symbol.iterator](): IterableIterator<T>;
 }
 export type FnCompareTwo<T> = (firstItem: T, secondItem: T) => boolean;
 declare abstract class AbstractBinaryNode<T> {
@@ -731,6 +621,9 @@ export declare class BinarySearchTree<T> extends AbstractBinaryTree<T> {
 	 * @throws {CollectionIsEmptyException} when tree is empty
 	 */
 	traverse(type: EnumTreeTraversalType, from?: T): Array<T>;
+	private storeInOrder;
+	private storePreOrder;
+	private storePostOrder;
 	/**
 	 * Calc max height of the largest branch of the tree
 	 */
@@ -957,6 +850,10 @@ declare abstract class AbstractLinkedList<T> implements ILinkedList<T> {
 	 * @example "4>7>10" will be reversed to "10>7>4"
 	 */
 	abstract reverse(): void;
+	/**
+	 * Iterator
+	 */
+	[Symbol.iterator](): IterableIterator<T>;
 }
 declare class DoubleLinkedNode<T> extends AbstractLinkedNode<T> {
 	protected _prev: DoubleLinkedNode<T> | null;
@@ -1118,6 +1015,172 @@ export declare class IterableDoubleLinkedList<T> extends DoubleLinkedList<T> imp
 	 */
 	iterator(fromIndex?: number): IBiDirectIterator<T>;
 }
+declare class GraphEdge<T> {
+	private readonly _fromVertex;
+	private readonly _toVertex;
+	private _weight;
+	/**
+	 * Create instance with linked "from" and "to" vertices
+	 */
+	constructor(fromVertex: T, toVertex: T, weight?: number);
+	get fromVertex(): T;
+	get toVertex(): T;
+	get weight(): number;
+	set weight(value: number);
+}
+declare abstract class AbstractGraph<T> {
+	protected _vertices: Map<T, Set<T>>;
+	protected _edges: Map<string, GraphEdge<T>>;
+	/**
+	 * Created empty instance
+	 */
+	protected constructor();
+	protected static readonly EDGE_KEY_SEPARATOR: string;
+	/**
+	 * Get edge key string from_to
+	 * @example Bob_Maria
+	 * @example Maria_Bob
+	 */
+	protected getEdgeKey(from: T, to: T): string;
+	/**
+	 * Find edge by its from and to vertices
+	 */
+	protected abstract getEdgeByValue(from: T, to: T): GraphEdge<T>;
+	/**
+	 * Get vertices list in array format
+	 */
+	protected getVerticesArrayFormat(): Array<T>;
+	/**
+	 * Find vertex in vertices list by its data
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	protected tryFindVertex(data: T): T;
+	/**
+	 * Update edge weight between from and to vertices
+	 */
+	protected updateEdgeWeight(from: T, to: T, weight: number): void;
+	/**
+	 * Will remove all vertex relations with others vertices
+	 */
+	protected cascadeRemoveVertexRelations(vertexToRemove: T): void;
+	/**
+	 * Will remove all vertices edges with vertex to remove
+	 */
+	protected cascadeRemoveVertexEdges(vertexToRemove: T): void;
+	/**
+	 * Get sum of all graph edges
+	 */
+	weight(): number;
+	/**
+	 * Get array of vertices
+	 */
+	vertices(): Array<T>;
+	/**
+	 * Get vertices count
+	 */
+	verticesCount(): number;
+	/**
+	 * Get edges count
+	 */
+	edgesCount(): number;
+	/**
+	 * Add vertex
+	 * @throws {IsAlreadyExistsException} when vertex is already exists
+	 */
+	addVertex(data: T): this;
+	/**
+	 * Remove vertex
+	 * @throws {IsNotFoundException} when vertex is already does not exist
+	 */
+	removeVertex(data: T): this;
+	/**
+	 * Add edge between two vertices
+	 */
+	abstract addEdge(from: T, to: T, weight?: number): this;
+	/**
+	 * Remove edge between two vertices
+	 */
+	abstract removeEdge(from: T, to: T): this;
+	/**
+	 * Get vertex neighbors by its data
+	 */
+	getVertexNeighbors(data: T): Array<T>;
+	/**
+	 * Check if graph has vertex
+	 */
+	hasVertex(data: T): boolean;
+	/**
+	 * Check if graph has edge between from and to vertices
+	 */
+	hasEdge(from: T, to: T): boolean;
+	/**
+	 * Get edge weight between from and to vertices
+	 */
+	getEdgeWeight(from: T, to: T): number;
+	/**
+	 * Iterator
+	 */
+	[Symbol.iterator](): IterableIterator<T>;
+}
+/**
+ * Directed graph - data structure where edges with same pair of vertices are not equal
+ * @example A-B is not the same as B-A
+ */
+export declare class DirectedGraph<T> extends AbstractGraph<T> {
+	/**
+	 * @inheritDoc
+	 */
+	constructor();
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	addEdge(from: T, to: T, weight?: number): this;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	removeEdge(from: T, to: T): this;
+	/**
+	 * @inheritDoc
+	 */
+	removeVertex(value: T): this;
+}
+/**
+ * Undirected graph - data structure where edges with same pair of vertices are equal
+ * @example A-B is same as B-A
+ */
+export declare class UndirectedGraph<T> extends AbstractGraph<T> {
+	/**
+	 * @inheritDoc
+	 */
+	constructor();
+	protected getEdgeKey(from: T, to: T): string;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	protected getEdgeByValue(from: T, to: T): GraphEdge<T>;
+	/**
+	 * @inheritDoc
+	 */
+	hasEdge(from: T, to: T): boolean;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	addEdge(from: T, to: T, weight?: number): this;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when vertex was not found
+	 */
+	removeEdge(from: T, to: T): this;
+}
 export declare class IllegalStateException extends Error {
 	constructor(message: string);
 }
@@ -1200,17 +1263,17 @@ export declare const getMinIndex: (arr: Array<number>) => number;
  */
 export declare const getMinIndexFromIndex: (arr: Array<number>, fromIndex: number) => number;
 /**
- * Will swap two items in array
- * @example swapArrayItems([2,3,5], 1, 2) -> [2,5,3]
+ * Round number to given digits after
  */
-export declare const swapArrayItems: <T>(arr: Array<T>, leftIndex: number, rightIndex: number) => void;
+export declare const roundNumber: (num: number, digits?: number) => number;
 /**
  * Get random number in range
  */
 export declare const randomizeNumberInRange: (min: number, max: number) => number;
 /**
- * Round number to given digits after
+ * Will swap two items in array
+ * @example swapArrayItems([2,3,5], 1, 2) -> [2,5,3]
  */
-export declare const roundNumber: (num: number, digits?: number) => number;
+export declare const swapArrayItems: <T>(arr: Array<T>, leftIndex: number, rightIndex: number) => void;
 
 export {};

package/lib/index.mjs

@@ -1 +1 @@
-const t=t=>{const e=/* @__PURE__ */new Map;return(...s)=>{const r=JSON.stringify(s);if(!e.has(r)){const i=t(...s);e.set(r,i)}return e.get(r)}},e=t=>t>1?t*e(t-1):t,s=t(t=>t>1?t*s(t-1):t),r=t=>t>1?r(t-1)+r(t-2):t,i=t(t=>t>1?i(t-1)+i(t-2):t),n=(t,e)=>{let s=0,r=t.length-1;for(;s<=r;){const i=Math.ceil((s+r)/2),n=t[i];if(e==n)return i;n>e?r=i-1:n<e&&(s=i+1)}return null};class h extends Error{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,h.prototype)}}const a=t=>t.reduce((e,s,r)=>s<t[e]?r:e,0),o=(t,e)=>e+a(t.slice(e)),l=(t,e,s)=>{if(e!==s){const r=t[e];t[e]=t[s],t[s]=r}},d=(t,e)=>Math.floor(Math.random()*(e-t))+t,u=(t,e=3)=>Math.round(t*10**e)/10**e,c=t=>{for(let e=0;e<t.length;e++){if(!(t[e].length===t.length))return!1}return!0},p=t=>{if(!c(t))throw new h("Given array is not a matrix");return t.reduce((e,s,r)=>(e[r]=t.map(t=>t[r]),e),new Array(t.length))};var g=/* @__PURE__ */(t=>(t.DIRECTED="DIRECTED",t.UNDIRECTED="UNDIRECTED",t))(g||{});class _ extends Error{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,_.prototype)}}class f extends _{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,f.prototype)}}class x extends _{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,x.prototype)}}class w{_vertices;_edges;constructor(){this._vertices=/* @__PURE__ */new Map,this._edges=new Array}getVerticesArrayFormat(){return Array.from(this._vertices.keys())}tryFindVertex(t){if(!this._vertices.has(t))throw new f("Vertex not found");return t}updateEdgeWeight(t,e,s){this.getEdgeByValue(t,e).weight=s}cascadeRemoveVertexRelations(t){this.getVerticesArrayFormat().forEach(e=>{const s=this._vertices.get(e);if(s){const r=s.filter(e=>e!==t);this._vertices.set(e,r)}})}cascadeRemoveVertexEdges(t){this._edges=this._edges.filter(e=>!(e.toVertex===t||e.fromVertex===t))}weight(){return this._edges.reduce((t,e)=>t+e.weight,0)}vertices(){return this.getVerticesArrayFormat().map(t=>t)}verticesCount(){return this.vertices().length}edgesCount(){return this._edges.length}addVertex(t){if(this.hasVertex(t))throw new x("Vertex is already exist");return this._vertices.set(t,new Array),this}removeVertex(t){try{const e=this.tryFindVertex(t);this.cascadeRemoveVertexEdges(e),this.cascadeRemoveVertexRelations(e),this._vertices.delete(e)}catch(e){throw new f("Vertex does not exist already")}return this}getVertexNeighbors(t){const e=this.tryFindVertex(t);return this._vertices.get(e)||[]}hasVertex(t){return this._vertices.has(t)}hasEdge(t,e){return Boolean(this._edges.find(s=>s.fromVertex===t&&s.toVertex===e))}getEdgeWeight(t,e){const s=this.tryFindVertex(t),r=this.tryFindVertex(e);return this.getEdgeByValue(s,r).weight}}class m{_fromVertex;_toVertex;_weight;constructor(t,e,s=0){this._fromVertex=t,this._toVertex=e,this._weight=s}get fromVertex(){return this._fromVertex}get toVertex(){return this._toVertex}get weight(){return this._weight}set weight(t){this._weight=t}}class E extends w{constructor(){super()}getEdgeByValue(t,e){const s=this._edges.find(s=>s.fromVertex===t&&s.toVertex===e);if(!s)throw new f("Edge not found");return s}addEdge(t,e,s){try{const r=this.tryFindVertex(t),i=this.tryFindVertex(e);if(this.hasEdge(r,i))"number"==typeof s&&this.updateEdgeWeight(r,i,s);else{const t=new m(r,i,s);this._edges.push(t),this._vertices.get(r)?.push(i)}}catch{throw new f("Edge cannot be added because one of vertices was not found")}return this}removeEdge(t,e){try{const s=this.tryFindVertex(t),r=this.tryFindVertex(e),i=this.getEdgeByValue(s,r),n=(this._vertices.get(s)||[]).filter(t=>r!==t);this._vertices.set(s,n),this._edges=this._edges.filter(t=>t!==i)}catch{throw new f("Edge cannot be removed because one of vertices was not found")}return this}}class y extends w{constructor(){super()}getEdgeByValue(t,e){const s=this._edges.find(s=>s.fromVertex===t&&s.toVertex===e||s.fromVertex===e&&s.toVertex===t);if(!s)throw new f("Edge not found");return s}hasEdge(t,e){return Boolean(this._edges.find(s=>s.fromVertex===t&&s.toVertex===e||s.fromVertex===e&&s.toVertex===t))}addEdge(t,e,s){try{const r=this.tryFindVertex(t),i=this.tryFindVertex(e);if(this.hasEdge(r,i))"number"==typeof s&&this.updateEdgeWeight(r,i,s);else{const t=new m(r,i,s);this._edges.push(t),this._vertices.get(r)?.push(i),this._vertices.get(i)?.push(r)}}catch{throw new f("Edge cannot be added because one of vertices was not found")}return this}removeEdge(t,e){try{const s=this.tryFindVertex(t),r=this.tryFindVertex(e),i=this.getEdgeByValue(s,r),n=this._vertices.get(s)||[],h=this._vertices.get(r)||[],a=n.filter(t=>r!==t),o=h.filter(t=>s!==t);this._vertices.set(s,a),this._vertices.set(r,o),this._edges=this._edges.filter(t=>t!==i)}catch{throw new f("Edge cannot be removed because one of vertices was not found")}return this}}const v=t=>{let e;switch(t){case g.DIRECTED:e=new E;break;case g.UNDIRECTED:e=new y}return e},N=1,I=0,V=(t,e,s)=>{if(!c(t))throw new h("Given array is not a matrix");const r=v(s);return e.forEach(t=>{r.addVertex(t)}),t.forEach((i,n)=>{i.forEach((i,h)=>{const a=t[n][h],o=t[h][n];s===g.UNDIRECTED&&1===a&&1===o&&r.addEdge(e[n],e[h]),s===g.DIRECTED&&(1===a&&r.addEdge(e[n],e[h]),1===o&&r.addEdge(e[h],e[n]))})}),r},R=t=>{const e=t.vertices(),s=new Array(t.verticesCount());return e.forEach((r,i)=>{s[i]=new Array(t.verticesCount()),e.forEach((e,n)=>{const h=t.hasEdge(r,e);s[i][n]=h?1:0})}),s},k=t=>{const e=t.vertices(),s=R(t),r=p(s);return V(r,e,g.DIRECTED)};class b extends h{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,b.prototype)}}class D extends _{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,D.prototype)}}class B extends _{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,B.prototype)}}class C extends h{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,C.prototype)}}class O{_capacity;_length;_head;_tail;constructor(t){this._capacity=O.calculateCapacity(t),this._head=null,this._tail=null,this._length=0}static calculateCapacity(t){if(void 0===t)return Number.MAX_VALUE;if(t<=0)throw new b("Capacity must be larger than 0");return t}insertNodeBetweenTwoNodes(t,e,s){if(this.isFull())throw new D("List is full, no more space available");null===this._head&&(this._head=t),null===this._tail&&(this._tail=t),e||(e=this._tail),s||(s=this._head),this.insertNodeBetweenTwoNodesImpl(t,e,s),this._length++}deleteNode(t){if(this.isEmpty())throw new B("cannot delete because list is empty");return this.deleteNodeImpl(t),this._length--,this.isEmpty()&&this.clear(),t}getNodeByIndex(t){const e=t<0||t>this._length;if(this.isEmpty())throw new B("List is empty");if(e)throw new C("Index exceed list length");let s=this._tail,r=0;for(;s&&r<t;)s=s.next,r++;return s}unshift(t){const e=this.createNode(t);this.insertNodeBetweenTwoNodes(e,this._head,this._tail),this._tail=e}push(t){const e=this.createNode(t);this.insertNodeBetweenTwoNodes(e,this._head,this._tail),this._head=e}pushFromIndex(t,e){const s=e<0||e>this._length,r=this.isEmpty()&&0===e;if(s)throw new C("index must be in range between 0 and list length");if(r)this.push(t);else{const s=this.createNode(t),r=this.getNodeByIndex(e-1),i=this.getNodeByIndex(e);this.insertNodeBetweenTwoNodes(s,r,i)}}pop(){const t=this.deleteNode(this._head);return this.popImpl(),t.data}shift(){const t=this.deleteNode(this._tail);return this.shiftImpl(),t.data}deleteFromIndex(t){const e=this.getNodeByIndex(t);return this.deleteNode(e).data}length(){return this._length}isEmpty(){return 0===this._length||null===this._head||null===this._tail}isFull(){return this._length>=this._capacity}has(t){return this.getAsArray().includes(t)}peek(){if(this.isEmpty()||!this._head)throw new B("head does not exist");return this._head.data}peekFromStart(){if(this.isEmpty()||!this._tail)throw new B("tail does not exist");return this._tail.data}peekByIndex(t){return this.getNodeByIndex(t).data}clear(){this._head=null,this._tail=null,this._length=0}getAsArray(){const t=[];let e=this._tail,s=0;for(;e&&s<this._length;)e&&t.push(e.data),e=e.next,s++;return t}pushFromArray(t){t.forEach(t=>{if(this.isFull())throw new D("List is full, no more space available");this.push(t)})}}class T{_next;_data;constructor(t,e=null){this._data=t,this._next=e}get data(){return this._data}get next(){return this._next}set next(t){this._next=t}}class F extends T{_prev;_next;constructor(t,e=null,s=null){super(t),this._prev=s,this._next=e}set prev(t){this._prev=t}get prev(){return this._prev}set next(t){this._next=t}get next(){return this._next}}class P extends O{_head;_tail;constructor(t){super(t),this._head=null,this._tail=null}createNode(t){return new F(t)}insertNodeBetweenTwoNodesImpl(t,e,s){t.next=s,t.prev=e,t.prev&&(t.prev.next=t),t.next&&(t.next.prev=t)}deleteNodeImpl(t){t.prev.next=t.next,t.next.prev=t.prev,t.next=null,t.prev=null}popImpl(){this._head=this._tail?.prev||null}shiftImpl(){this._tail=this._head?.next||null}reverse(){let t=this._tail,e=0;for(;t&&e<this._length;){const s=t.next,r=t.prev;t.prev=s,t.next=r,e++,t=r}t&&(this._tail=t.next,this._head=t)}}class S{_list;constructor(t){this._list=new P(t)}peek(){if(this.isEmpty())throw new B("Cannot peek when list is empty");return this._list.peek()}push(t){if(this._list.isFull())throw new D("Cannot push when queue is full");this._list.unshift(t)}pop(){if(this.isEmpty())throw new B("Cannot pop when list is empty");return this._list.pop()}has(t){return this._list.has(t)}isEmpty(){return this._list.isEmpty()}isFull(){return this._list.isFull()}clear(){this._list.clear()}length(){return this._list.length()}reverse(){this._list.reverse()}}class A{graph;visited;parents;constructor(t){this.graph=t,this.visited=/* @__PURE__ */new Map,this.parents=/* @__PURE__ */new Map}initIterator(t){if(!this.graph.hasVertex(t))throw new f("Start vertex does not exist");this.initIteratorImpl(t)}hasNext(){return this.hasNextImpl()}next(){if(!this.hasNext())throw new _("Next element does not exist");return this.nextImpl()}current(){try{return this.currentImpl()}catch(t){throw new _("Current element does not exist")}}getPath(t,e){const s=new Array,r=this.graph.hasEdge(t,e);let i=this.parents.get(e);if(r)return[t,e];for(;i&&i!==t;)s.push(i),i=this.parents.get(i);if(0===s.length)throw new _("There is no path found");return[t,...s.reverse(),e]}}class M extends A{queue;constructor(t){super(t),this.queue=new S}currentImpl(){return this.queue.peek()}initIteratorImpl(t){this.queue.push(t),this.visited.set(t,!0)}hasNextImpl(){return!this.queue.isEmpty()}nextImpl(){const t=this.queue.pop();return this.graph.getVertexNeighbors(t).forEach(e=>{!this.visited.get(e)&&(this.queue.push(e),this.visited.set(e,!0),this.parents.set(e,t))}),t}}class L{createIterator(t){return new M(t)}}class j{_list;constructor(t){this._list=new P(t)}peek(){if(this.isEmpty())throw new B("Cannot peek when list is empty");return this._list.peek()}push(t){if(this.isFull())throw new D("Stack is full");this._list.push(t)}pop(){if(this.isEmpty())throw new B("Cannot pop when stack is empty");return this._list.pop()}has(t){return this._list.has(t)}isEmpty(){return this._list.isEmpty()}isFull(){return this._list.isFull()}clear(){this._list.clear()}length(){return this._list.length()}reverse(){this._list.reverse()}}class U extends A{stack;constructor(t){super(t),this.stack=new j}hasNextImpl(){return!this.stack.isEmpty()}initIteratorImpl(t){this.stack.push(t),this.visited.set(t,!0)}currentImpl(){return this.stack.peek()}nextImpl(){const t=this.stack.pop();return this.graph.getVertexNeighbors(t).forEach(e=>{!this.visited.get(e)&&(this.stack.push(e),this.visited.set(e,!0),this.parents.set(e,t))}),t}}class q{createIterator(t){return new U(t)}}class H extends A{costs;constructor(t){super(t),this.costs=/* @__PURE__ */new Map}getClosestNotVisited(){const t=Array.from(this.costs.keys()).filter(t=>!this.visited.get(t)).sort((t,e)=>(this.costs.get(t)||0)-(this.costs.get(e)||0));if(void 0===t[0])throw new _("No more vertices found");return t[0]}initIteratorImpl(t){this.visited.set(t,!0),this.costs.set(t,0),this.graph.getVertexNeighbors(t).forEach(e=>{const s=this.graph.getEdgeWeight(t,e);this.costs.set(e,s),this.parents.set(e,t)})}hasNextImpl(){return!(null===this.getClosestNotVisited())}currentImpl(){return this.getClosestNotVisited()}nextImpl(){const t=this.getClosestNotVisited();this.visited.set(t,!0);const e=this.graph.getVertexNeighbors(t),s=this.costs.get(t);return e.forEach(e=>{const r=this.graph.getEdgeWeight(t,e),i=this.costs.get(e)||1/0,n=(s||0)+r;n<i&&(this.costs.set(e,n),this.parents.set(e,t))}),t}}class W{createIterator(t){return new H(t)}}const G=(t,e,s,r)=>{if(!t.hasVertex(e))throw new f("Start vertex was not found");if(!t.hasVertex(s))throw new f("End vertex was not found");const i=r.createIterator(t);for(i.initIterator(e);i.hasNext();){if(i.next()===s)return!0}return!1},Z=(t,e,s,r)=>{if(!t.hasVertex(e))throw new f("Start vertex was not found");if(!t.hasVertex(s))throw new f("End vertex was not found");const i=r.createIterator(t);for(i.initIterator(e);i.hasNext();){if(i.next()===s)break}return i.getPath(e,s)},z=t=>t.vertices().reduce((e,s)=>{const r=t.getVertexNeighbors(s);return e.set(s,r),e},/* @__PURE__ */new Map);var J=/* @__PURE__ */(t=>(t.NUMBERS="NUMBERS",t.HASH="HASH",t))(J||{});const X=()=>"_"+Math.random().toString(36).substr(2,9),$=(t,e,s=g.UNDIRECTED,r=J.NUMBERS)=>{const i=v(s),n=((t,e)=>{let s=e*(e-1);switch(t){case g.DIRECTED:break;case g.UNDIRECTED:s=Math.floor(s/2)}return s})(s,t);if(e<=0||e>n)throw new b(`Edges count must be in range between 0 and ${n}`);((t,e,s)=>{switch(e){case J.HASH:for(let e=0;e<s;e++)t.addVertex(X());break;case J.NUMBERS:for(let e=0;e<s;e++)t.addVertex((e+1).toString())}})(i,r,t);const h=i.vertices();let a=0;for(;a<e;){const t=()=>d(0,h.length),e=h[t()],s=h[t()],r=i.hasEdge(e,s);e===s||r||(i.addEdge(e,s),a++)}return i};var K=/* @__PURE__ */(t=>(t.DOUBLE="Double linked list",t.SINGLE="Single linked list",t))(K||{});class Q extends T{constructor(t,e=null){super(t,e)}}class Y extends O{_head;_tail;constructor(t){super(t),this._head=null,this._tail=null}getPrevNode(t){let e=this._tail;for(;e?.next!==t;)e=e?.next||null;return e}createNode(t){return new Q(t)}insertNodeBetweenTwoNodesImpl(t,e,s){t.next=s,e&&(e.next=t)}deleteNodeImpl(t){this.getPrevNode(t).next=t.next,t.next=null}popImpl(){this._head=this.getPrevNode(this._tail)}shiftImpl(){this._tail=this._head?.next||null}reverse(){let t=this._tail,e=this._head,s=0;for(;s<this._length;){const r=t?.next||null;t&&(t.next=e),s++,e=t,t=r}t&&(this._head=t,this._tail=t.next)}}class tt extends P{constructor(t){super(t)}iterator(t=0){const e=this._head,s=this._tail;let r=this.getNodeByIndex(t);const i={current:()=>r.data,hasNext:()=>Boolean(r.next)&&r!==e,hasPrev:()=>Boolean(r.prev)&&r!==s,next:()=>{if(!i.hasNext())throw new f("Next element does not exist");return r=r.next,r.data},prev:()=>{if(!i.hasPrev())throw new f("Prev element does not exist");return r=r.prev,r.data}};return i}}class et extends Y{constructor(t){super(t)}iterator(t=0){const e=this._head;let s=this.getNodeByIndex(t);const r={current:()=>s.data,hasNext:()=>Boolean(s.next)&&s!==e,next:()=>{if(!r.hasNext())throw new f("Next element does not exist");return s=s.next,s.data}};return r}}const st=(t,e=!1,s)=>{let r;if(e)switch(t){case K.DOUBLE:r=new tt(s);break;case K.SINGLE:r=new et(s)}else switch(t){case K.DOUBLE:r=new P(s);break;case K.SINGLE:r=new Y(s)}return r};var rt=/* @__PURE__ */(t=>(t.BST="Binary Search Tree",t.RANDOMIZED_BST="Randomized Binary Search Tree",t))(rt||{}),it=/* @__PURE__ */(t=>(t.IN_ORDER="IN_ORDER",t.PRE_ORDER="PRE_ORDER",t.POST_ORDER="POST_ORDER",t))(it||{});class nt{compare=(t,e)=>t>e;_head;_length;constructor(t){t&&(this.compare=t),this._head=null,this._length=0}length(){return this._length}}class ht{_data;_left;_right;_parent;constructor(t){this._data=t,this._left=null,this._right=null,this._parent=null}get data(){return this._data}set data(t){this._data=t}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class at extends ht{_left;_right;_parent;constructor(t){super(t),this._left=null,this._right=null,this._parent=null}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class ot extends nt{_head;constructor(t){super(t),this._head=null}checkIsEmpty(){if(null===this._head)throw new B("Tree is empty")}updateLeftRightParents(t){t.left&&t.left.parent!==t&&(t.left.parent=t),t.right&&t.right.parent!==t&&(t.right.parent=t)}findNode(t){let e=this._head;for(;e&&e.data!==t;)e=this.compare(e.data,t)?e.left:e.right;return e}insertToLeaf(t){let e=null,s=this._head;for(;s;)e=s,s=this.compare(s.data,t.data)?s.left:s.right;t.parent=e,null===e?this._head=t:this.compare(e.data,t.data)?e.left=t:e.right=t,this._length++}join(t,e){return null===t?e:null===e?t:(e.left=this.join(t,e.left),e.left&&this.updateLeftRightParents(e),e)}max(){this.checkIsEmpty();let t=this._head;for(;t?.right;)t=t.right;return t.data}min(){this.checkIsEmpty();let t=this._head;for(;t?.left;)t=t.left;return t.data}insert(t){if(this.has(t))throw new x("Node already exists");const e=new at(t);this.insertToLeaf(e)}has(t){const e=this.findNode(t);return e?.data===t}delete(t){if(!this.has(t))throw new f("Value does not exist in the tree");const e=(t,s)=>{if(null===t)return t;if(t.data===s){const e=this.join(t.left,t.right);return e&&(e.parent=t.parent),e}return this.compare(t.data,s)?t.left=e(t.left,s):t.right=e(t.right,s),this.updateLeftRightParents(t),t};this._head=e(this._head,t),this._length--}subtree(t){const e=new ot,s=this.findNode(t),r=new S,i=[];for(r.push(s);!r.isEmpty();){const t=r.pop();i.push(t),t?.left&&r.push(t.left),t?.right&&r.push(t.right)}return i.forEach(t=>{null!==t&&e.insert(t.data)}),e}traverse(t,e){this.checkIsEmpty();const s=new Array(this.length()),r=void 0!==e?this.findNode(e):this._head,i=t=>{null!==t&&(i(t.left),s.push(t.data),i(t.right))};switch(t){case it.IN_ORDER:i(r);break;case it.POST_ORDER:null!==(n=r)&&(i(n.left),i(n.right),s.push(n.data));break;case it.PRE_ORDER:(t=>{null!==t&&(s.push(t.data),i(t.left),i(t.right))})(r)}var n;return s.filter(t=>void 0!==t)}height(){const t=e=>{if(null===e)return 0;const s=null===e.left?-1:t(e.left),r=null===e.right?-1:t(e.right);return(s>r?s:r)+1};return null===this._head?0:t(this._head)+1}}class lt extends at{_rank;_left;_right;_parent;constructor(t){super(t),this._rank=0,this._left=null,this._right=null,this._parent=null}get rank(){return this._rank}set rank(t){this._rank=t}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class dt extends ot{_head;constructor(t){super(t),this._head=null}updateRank(t){t.rank=(t.right?.rank||0)+(t.left?.rank||0)+1}addCreatedNode(t,e=null){return t.rank=1,null!==e&&(t.parent=e),t}rotateNodeRight(t){const e=t.left;null!==e&&(t.left=e.right,null!==e.right&&(e.right.parent=t),e.parent=t.parent,null===t.parent?this._head=e:t===t.parent.right?t.parent.right=e:t.parent.left=e,e.right=t,t.parent=e,this.updateRank(t),this.updateRank(e))}rotateNodeLeft(t){const e=t.right;null!==e&&(t.right=e.left,null!==e.left&&(e.left.parent=t),e.parent=t.parent,null===t.parent?this._head=e:t===t.parent.left?t.parent.left=e:t.parent.right=e,e.left=t,t.parent=e,this.updateRank(t),this.updateRank(e))}join(t,e){return null===t?e:null===e?t:Math.random()<t.rank/(t.rank+e.rank)?(t.right=this.join(t.right,e),t.right&&this.updateLeftRightParents(t),this.updateRank(t),t):(e.left=this.join(t,e.left),e.left&&this.updateLeftRightParents(e),this.updateRank(e),e)}updateLeftRightParents(t){super.updateLeftRightParents(t),this.updateRank(t)}insertToRoot(t,e){const s=e=>{this.compare(e.data,t.data)?(null===e.left?e.left=this.addCreatedNode(t,e):s(e.left),this.rotateNodeRight(e)):(null===e.right?e.right=this.addCreatedNode(t,e):s(e.right),this.rotateNodeLeft(e))};null===this._head?this._head=this.addCreatedNode(t):s(e||this._head)}insertRandomly(t){const e=s=>{Math.random()<1/(s.rank+1)?this.insertToRoot(t,s):(s.rank=s.rank+1,this.compare(s.data,t.data)?null===s.left?s.left=this.addCreatedNode(t,s):e(s.left):null===s.right?s.right=this.addCreatedNode(t,s):e(s.right))};null===this._head?this._head=this.addCreatedNode(t):e(this._head)}insert(t){if(this.has(t))throw new x("Node already exists");const e=new lt(t);this.insertRandomly(e)}delete(t){super.delete(t),this._length=this.length()}length(){return this._head?.rank||0}}const ut=t=>{let e;switch(t){case rt.BST:e=new ot;break;case rt.RANDOMIZED_BST:e=new dt}return e},ct=t=>{for(let e=0;e<t.length-1;e++)for(let s=0;s<t.length-1;s++)t[s]>t[s+1]&&l(t,s,s+1);return t},pt=t=>{for(let e=0;e<t.length;e++){const s=o(t,e);l(t,s,e)}return t},gt=(t,e,s)=>{if(s>e){const r=Math.floor(e+(s-e)/2);gt(t,e,r),gt(t,r+1,s),((t,e,s,r)=>{const i=t.slice(e,r+1);let n=e,h=e,a=s+1;for(;h<=s&&a<=r;){const s=i[h-e],r=i[a-e];s<r?(t[n]=s,h++):(t[n]=r,a++),n++}for(;h<=s;)t[n]=i[h-e],n++,h++;for(;a<=r;)t[n]=i[a-e],n++,a++})(t,e,r,s)}},_t=t=>(gt(t,0,t.length-1),t),ft=t=>{for(let e=1;e<t.length;e++){const s=t[e];let r=e-1;for(;r>=0&&t[r]>s;)l(t,r+1,r),r--;t[r+1]=s}return t},xt=t=>{const e=(t,s=0,r=t.length-1)=>{if(s<r){const i=((t,e,s)=>{const r=t[e];let i=e,n=s;for(;i<=n;){for(;t[n]>r;)n--;for(;t[i]<r;)i++;i<=n&&(l(t,i,n),n--,i++)}return i})(t,s,r);e(t,s,i-1),e(t,i,r)}return t};return e(t)};export{L as BFSIterationStrategy,ot as BinarySearchTree,B as CollectionIsEmptyException,D as CollectionIsFullException,q as DFSIterationStrategy,W as DijkstraIterationStrategy,E as DirectedGraph,P as DoubleLinkedList,N as EDGE_EXISTS_STATE,I as EDGE_NOT_EXISTS_STATE,M as GraphIteratorBFS,U as GraphIteratorDFS,H as GraphIteratorDijkstra,h as IllegalArgumentException,_ as IllegalStateException,C as IndexOutOfBoundsException,x as IsAlreadyExistsException,f as IsNotFoundException,tt as IterableDoubleLinkedList,et as IterableSingleLinkedList,S as Queue,dt as RandBinarySearchTree,Y as SingleLinkedList,j as Stack,y as UndirectedGraph,b as ValueOutOfRangeException,n as binarySearch,ct as bubbleSort,ut as createBinaryTree,v as createGraph,V as createGraphFromMatrix,st as createLinkedList,e as factorial,r as fibonacci,$ as generateRandomGraph,a as getMinIndex,o as getMinIndexFromIndex,G as hasPath,ft as insertionSort,t as memoize,s as memoizedFactorial,i as memoizedFibonacci,_t as mergeSort,z as presenterAdjacencyLists,R as presenterAdjacencyMatrix,xt as quickSort,d as randomizeNumberInRange,u as roundNumber,pt as selectSort,Z as shortestPath,l as swapArrayItems,k as transposeDirectedGraph,p as transposeMatrix};
+const t=1,e=0,s=t=>{const e=/* @__PURE__ */new Map;return(...s)=>{const r=JSON.stringify(s);if(!e.has(r)){const i=t(...s);e.set(r,i)}return e.get(r)}},r=t=>t<0?0:t>1?t*r(t-1):1,i=s(t=>t<0?0:t>1?t*i(t-1):1),h=t=>t>1?h(t-1)+h(t-2):t,n=s(t=>t>1?n(t-1)+n(t-2):t),a=(t,e)=>{let s=0,r=t.length-1;for(;s<=r;){const i=Math.floor(s+(r-s)/2),h=t[i];if(e===h)return i;h>e?r=i-1:s=i+1}return null};class o extends Error{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,o.prototype)}}const l=t=>{if(0===t.length)return!1;const e=t[0].length;for(let s=0;s<t.length;s++)if(t[s].length!==e)return!1;return!0},u=t=>{if(!l(t))throw new o("Given array is not a matrix");const e=t.length,s=t[0]?.length||0,r=[];for(let i=0;i<s;i++){r[i]=[];for(let s=0;s<e;s++)r[i][s]=t[s][i]}return r};var d=/* @__PURE__ */(t=>(t.DIRECTED="DIRECTED",t.UNDIRECTED="UNDIRECTED",t))(d||{});class c extends Error{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,c.prototype)}}class p extends c{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,p.prototype)}}class g extends c{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,g.prototype)}}class _{_vertices;_edges;constructor(){this._vertices=/* @__PURE__ */new Map,this._edges=/* @__PURE__ */new Map}static EDGE_KEY_SEPARATOR="_";getEdgeKey(t,e){return`${t}${_.EDGE_KEY_SEPARATOR}${e}`}getVerticesArrayFormat(){return Array.from(this._vertices.keys())}tryFindVertex(t){if(!this._vertices.has(t))throw new p("Vertex not found");return t}updateEdgeWeight(t,e,s){this.getEdgeByValue(t,e).weight=s}cascadeRemoveVertexRelations(t){const e=this._vertices.get(t);e&&e.forEach(e=>{this._vertices.get(e)?.delete(t),this._edges.delete(this.getEdgeKey(e,t))})}cascadeRemoveVertexEdges(t){for(const[e,s]of this._edges.entries())s.fromVertex!==t&&s.toVertex!==t||this._edges.delete(e)}weight(){let t=0;for(const e of this._edges.values())t+=e.weight;return t}vertices(){return this.getVerticesArrayFormat().map(t=>t)}verticesCount(){return this._vertices.size}edgesCount(){return this._edges.size}addVertex(t){if(this.hasVertex(t))throw new g("Vertex is already exist");return this._vertices.set(t,/* @__PURE__ */new Set),this}removeVertex(t){try{const e=this.tryFindVertex(t);this.cascadeRemoveVertexEdges(e),this.cascadeRemoveVertexRelations(e),this._vertices.delete(e)}catch{throw new p("Vertex does not exist already")}return this}getVertexNeighbors(t){const e=this.tryFindVertex(t),s=this._vertices.get(e);return s?Array.from(s):[]}hasVertex(t){return this._vertices.has(t)}hasEdge(t,e){return this._edges.has(this.getEdgeKey(t,e))}getEdgeWeight(t,e){const s=this.tryFindVertex(t),r=this.tryFindVertex(e);return this.getEdgeByValue(s,r).weight}*[Symbol.iterator](){yield*this._vertices.keys()}}class f{_fromVertex;_toVertex;_weight;constructor(t,e,s=0){this._fromVertex=t,this._toVertex=e,this._weight=s}get fromVertex(){return this._fromVertex}get toVertex(){return this._toVertex}get weight(){return this._weight}set weight(t){this._weight=t}}class x extends _{constructor(){super()}getEdgeByValue(t,e){const s=this.getEdgeKey(t,e),r=this._edges.get(s);if(!r)throw new p("Edge was not found");return r}addEdge(t,e,s){try{const r=this.tryFindVertex(t),i=this.tryFindVertex(e),h=this.getEdgeKey(r,i);if(this.hasEdge(r,i))"number"==typeof s&&this.updateEdgeWeight(r,i,s);else{const t=new f(r,i,s);this._edges.set(h,t),this._vertices.get(r)?.add(i)}}catch{throw new p("Edge cannot be added because one of vertices was not found")}return this}removeEdge(t,e){const s=this.tryFindVertex(t),r=this.tryFindVertex(e),i=this.getEdgeKey(s,r);if(!this._edges.has(i))throw new p("Edge cannot be removed because edge was not found");return this._vertices.get(s)?.delete(r),this._edges.delete(i),this}removeVertex(t){const e=this.tryFindVertex(t);for(const[s,r]of this._edges.entries())r.fromVertex!==e&&r.toVertex!==e||this._edges.delete(s);return this._vertices.forEach(t=>{t.delete(e)}),this._vertices.delete(e),this}}class w extends _{constructor(){super()}getEdgeKey(t,e){return this instanceof w?[t,e].sort().join(w.EDGE_KEY_SEPARATOR):`${t}${w.EDGE_KEY_SEPARATOR}${e}`}getEdgeByValue(t,e){const s=this.getEdgeKey(t,e),r=this._edges.get(s);if(!r)throw new p("Edge not found");return r}hasEdge(t,e){return this._edges.has(this.getEdgeKey(t,e))}addEdge(t,e,s){try{const r=this.tryFindVertex(t),i=this.tryFindVertex(e),h=this.getEdgeKey(r,i);if(this.hasEdge(r,i))"number"==typeof s&&this.updateEdgeWeight(r,i,s);else{const t=new f(r,i,s);this._edges.set(h,t),this._vertices.get(r)?.add(i),this._vertices.get(i)?.add(r)}}catch{throw new p("Edge cannot be added because one of vertices was not found")}return this}removeEdge(t,e){const s=this.tryFindVertex(t),r=this.tryFindVertex(e),i=this.getEdgeKey(s,r);if(!this.hasEdge(s,r))throw new p("Edge cannot be removed because edge was not found");return this._edges.delete(i),this._vertices.get(s)?.delete(r),this._vertices.get(r)?.delete(s),this}}const m=t=>{let e;switch(t){case d.DIRECTED:e=new x;break;case d.UNDIRECTED:e=new w}return e},y=(t,e,s)=>{if(!(l(t)&&t.length===t[0]?.length&&t.length===e.length))throw new o("Given array is not a matrix");const r=m(s);return e.forEach(t=>r.addVertex(t)),t.forEach((t,i)=>{t.forEach((t,h)=>{if(1===t){const t=e[i],n=e[h];s===d.UNDIRECTED&&(r.hasEdge(t,n)||r.hasEdge(n,t))||r.addEdge(t,n)}})}),r},E=t=>{const e=t.vertices(),s=new Array(t.verticesCount());return e.forEach((r,i)=>{s[i]=new Array(t.verticesCount()),e.forEach((e,h)=>{const n=t.hasEdge(r,e);s[i][h]=n?1:0})}),s},v=t=>{const e=t.vertices(),s=E(t),r=u(s);return y(r,e,d.DIRECTED)};class N extends o{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,N.prototype)}}class I extends c{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,I.prototype)}}class R extends c{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,R.prototype)}}class k extends o{constructor(t){super(t),this.name=this.constructor.name,Object.setPrototypeOf(this,k.prototype)}}class V{_capacity;_length;_head;_tail;constructor(t){this._capacity=V.calculateCapacity(t),this._head=null,this._tail=null,this._length=0}static calculateCapacity(t){if(void 0===t)return Number.MAX_VALUE;if(t<=0)throw new N("Capacity must be larger than 0");return t}insertNodeBetweenTwoNodes(t,e,s){if(this.isFull())throw new I("List is full, no more space available");null===this._head&&(this._head=t),null===this._tail&&(this._tail=t),e||(e=this._tail),s||(s=this._head),this.insertNodeBetweenTwoNodesImpl(t,e,s),this._length++}deleteNode(t){if(null===t||this.isEmpty())throw new R("cannot delete because list is empty");return this.deleteNodeImpl(t),this._length--,this.isEmpty()&&this.clear(),t}getNodeByIndex(t){const e=t<0||t>this._length;if(this.isEmpty())throw new R("List is empty");if(e)throw new k("Index exceed list length");let s=this._tail,r=0;for(;s&&r<t;)s=s.next,r++;return s}unshift(t){const e=this.createNode(t);this.insertNodeBetweenTwoNodes(e,this._head,this._tail),this._tail=e}push(t){const e=this.createNode(t);this.insertNodeBetweenTwoNodes(e,this._head,this._tail),this._head=e}pushFromIndex(t,e){const s=e<0||e>this._length,r=this.isEmpty()&&0===e;if(s)throw new k("index must be in range between 0 and list length");if(r)this.push(t);else{const s=this.createNode(t),r=this.getNodeByIndex(e-1),i=this.getNodeByIndex(e);this.insertNodeBetweenTwoNodes(s,r,i)}}pop(){const t=this.deleteNode(this._head);return this.popImpl(),t.data}shift(){const t=this.deleteNode(this._tail);return this.shiftImpl(),t.data}deleteFromIndex(t){const e=this.getNodeByIndex(t);return this.deleteNode(e).data}length(){return this._length}isEmpty(){return 0===this._length||null===this._head||null===this._tail}isFull(){return this._length>=this._capacity}has(t){return this.getAsArray().includes(t)}peek(){if(this.isEmpty()||!this._head)throw new R("head does not exist");return this._head.data}peekFromStart(){if(this.isEmpty()||!this._tail)throw new R("tail does not exist");return this._tail.data}peekByIndex(t){return this.getNodeByIndex(t).data}clear(){this._head=null,this._tail=null,this._length=0}getAsArray(){const t=[];let e=this._tail,s=0;for(;e&&s<this._length;)e&&t.push(e.data),e=e.next,s++;return t}pushFromArray(t){t.forEach(t=>{if(this.isFull())throw new I("List is full, no more space available");this.push(t)})}*[Symbol.iterator](){let t=this._tail;for(;t;)yield t.data,t=t.next}}class b{_next;_data;constructor(t,e=null){this._data=t,this._next=e}get data(){return this._data}get next(){return this._next}set next(t){this._next=t}}class O extends b{_prev;_next;constructor(t,e=null,s=null){super(t),this._prev=s,this._next=e}set prev(t){this._prev=t}get prev(){return this._prev}set next(t){this._next=t}get next(){return this._next}}class D extends V{_head;_tail;constructor(t){super(t),this._head=null,this._tail=null}createNode(t){return new O(t)}insertNodeBetweenTwoNodesImpl(t,e,s){t.next=s,t.prev=e,t.prev&&(t.prev.next=t),t.next&&(t.next.prev=t)}deleteNodeImpl(t){t.prev&&(t.prev.next=t.next),t.next&&(t.next.prev=t.prev),t.next=null,t.prev=null}popImpl(){this._head=this._tail?.prev||null}shiftImpl(){this._tail=this._head?.next||null}reverse(){let t=this._tail,e=0;for(;t&&e<this._length;){const s=t.next,r=t.prev;t.prev=s,t.next=r,e++,t=r}t&&(this._tail=t.next,this._head=t)}}class P{_list;constructor(t){this._list=new D(t)}peek(){if(this.isEmpty())throw new R("Cannot peek when list is empty");return this._list.peek()}push(t){if(this._list.isFull())throw new I("Cannot push when queue is full");this._list.unshift(t)}pop(){if(this.isEmpty())throw new R("Cannot pop when list is empty");return this._list.pop()}has(t){return this._list.has(t)}isEmpty(){return this._list.isEmpty()}isFull(){return this._list.isFull()}clear(){this._list.clear()}length(){return this._list.length()}reverse(){this._list.reverse()}}class T{graph;visited;parents;constructor(t){this.graph=t,this.visited=/* @__PURE__ */new Map,this.parents=/* @__PURE__ */new Map}initIterator(t){if(!this.graph.hasVertex(t))throw new p("Start vertex does not exist");this.initIteratorImpl(t)}hasNext(){return this.hasNextImpl()}next(){if(!this.hasNext())throw new c("Next element does not exist");return this.nextImpl()}current(){try{return this.currentImpl()}catch(t){throw new c("Current element does not exist")}}getPath(t,e){const s=new Array,r=this.graph.hasEdge(t,e);let i=this.parents.get(e);if(r)return[t,e];for(;i&&i!==t;)s.push(i),i=this.parents.get(i);if(0===s.length)throw new c("There is no path found");return[t,...s.reverse(),e]}}class C extends T{queue;constructor(t){super(t),this.queue=new P}currentImpl(){return this.queue.peek()}initIteratorImpl(t){this.queue.push(t),this.visited.set(t,!0)}hasNextImpl(){return!this.queue.isEmpty()}nextImpl(){const t=this.queue.pop();return this.graph.getVertexNeighbors(t).forEach(e=>{!this.visited.get(e)&&(this.queue.push(e),this.visited.set(e,!0),this.parents.set(e,t))}),t}}class B{_items=[];_capacity;constructor(t){this._capacity=t}length(){return this._items.length}isEmpty(){return 0===this._items.length}isFull(){return void 0!==this._capacity&&this._items.length===this._capacity}peek(){if(this.isEmpty())throw new R("Cannot peek when list is empty");return this._items[this._items.length-1]}push(t){if(this.isFull())throw new I("Stack is full");this._items.push(t)}pop(){if(this.isEmpty())throw new R("Cannot pop when stack is empty");return this._items.pop()}has(t){return this._items.includes(t)}clear(){this._items.length=0}reverse(){this._items.reverse()}*[Symbol.iterator](){yield*this._items}}class S extends T{stack;constructor(t){super(t),this.stack=new B}hasNextImpl(){return!this.stack.isEmpty()}initIteratorImpl(t){this.stack.push(t),this.visited.set(t,!0)}currentImpl(){return this.stack.peek()}nextImpl(){const t=this.stack.pop();return this.graph.getVertexNeighbors(t).forEach(e=>{!this.visited.get(e)&&(this.stack.push(e),this.visited.set(e,!0),this.parents.set(e,t))}),t}}class F{_heap=[];_comparator;constructor(t){this._comparator=t||this.defaultComparator}get size(){return this._heap.length}isEmpty(){return 0===this.size}peek(){if(this.isEmpty())throw new R("Cannot peek when heap is empty");return this._heap[0]}insert(t){this._heap.push(t),this.bubbleUp()}extractMin(){if(this.isEmpty())throw new R("Cannot extract from an empty heap");const t=this._heap[0],e=this._heap.pop();return this.isEmpty()||(this._heap[0]=e,this.bubbleDown()),t}defaultComparator(t,e){return t<e?-1:t>e?1:0}parentIndex(t){return Math.floor((t-1)/2)}leftChildIndex(t){return 2*t+1}rightChildIndex(t){return 2*t+2}swap(t,e){[this._heap[t],this._heap[e]]=[this._heap[e],this._heap[t]]}bubbleUp(){let t=this.size-1,e=this.parentIndex(t);for(;t>0&&this._comparator(this._heap[t],this._heap[e])<0;)this.swap(t,e),t=e,e=this.parentIndex(t)}bubbleDown(){let t=0;for(;;){const e=this.leftChildIndex(t),s=this.rightChildIndex(t);let r=t;if(e<this.size&&this._comparator(this._heap[e],this._heap[r])<0&&(r=e),s<this.size&&this._comparator(this._heap[s],this._heap[r])<0&&(r=s),r===t)break;this.swap(t,r),t=r}}*[Symbol.iterator](){yield*this._heap}}class q{_heap;constructor(){this._heap=new F((t,e)=>t.priority-e.priority)}get size(){return this._heap.size}isEmpty(){return this._heap.isEmpty()}enqueue(t,e){this._heap.insert({value:t,priority:e})}dequeue(){return this._heap.extractMin().value}peek(){return this._heap.peek().value}clear(){for(;!this.isEmpty();)this.dequeue()}}class A extends T{costs;queue;constructor(t){super(t),this.costs=/* @__PURE__ */new Map,this.queue=new q}initIteratorImpl(t){this.costs.set(t,0),this.queue.enqueue(t,0)}hasNextImpl(){return this.refreshQueue(),!this.queue.isEmpty()}currentImpl(){if(this.refreshQueue(),this.queue.isEmpty())throw new c("No more vertices found");return this.queue.peek()}nextImpl(){if(this.refreshQueue(),this.queue.isEmpty())throw new c("No more vertices found");const t=this.queue.dequeue();this.visited.set(t,!0);const e=this.graph.getVertexNeighbors(t),s=this.costs.get(t)??0;for(const r of e){if(this.visited.get(r))continue;const e=s+this.graph.getEdgeWeight(t,r);e<(this.costs.get(r)??1/0)&&(this.costs.set(r,e),this.parents.set(r,t),this.queue.enqueue(r,e))}return t}refreshQueue(){for(;!this.queue.isEmpty()&&this.visited.get(this.queue.peek());)this.queue.dequeue()}}var L=/* @__PURE__ */(t=>(t.BFS="Breadth first traversal",t.DFS="Deep first traversal",t.DIJKSTRA="Dijkstra traversal",t))(L||{});const M=(t,e)=>{switch(e){case L.BFS:return new C(t);case L.DFS:return new S(t);case L.DIJKSTRA:return new A(t);default:throw new o(`Unknown traversal mode: ${e}`)}},K=({graph:t,traversalType:e,from:s,to:r})=>{if(!t.hasVertex(s))throw new p("Start vertex was not found");if(!t.hasVertex(r))throw new p("End vertex was not found");const i=M(t,e);for(i.initIterator(s);i.hasNext();){if(i.next()===r)return!0}return!1},j=({graph:t,traversalType:e,from:s,to:r})=>{if(!t.hasVertex(s))throw new p("Start vertex was not found");if(!t.hasVertex(r))throw new p("End vertex was not found");const i=M(t,e);for(i.initIterator(s);i.hasNext();){if(i.next()===r)break}return i.getPath(s,r)},U=t=>t.vertices().reduce((e,s)=>{const r=t.getVertexNeighbors(s);return e.set(s,r),e},/* @__PURE__ */new Map);var z=/* @__PURE__ */(t=>(t.DOUBLE="Double linked list",t.SINGLE="Single linked list",t))(z||{});class G extends b{constructor(t,e=null){super(t,e)}}class $ extends V{_head;_tail;constructor(t){super(t),this._head=null,this._tail=null}getPrevNode(t){let e=this._tail;for(;e?.next!==t;)e=e?.next||null;return e}createNode(t){return new G(t)}insertNodeBetweenTwoNodesImpl(t,e,s){t.next=s,e&&(e.next=t)}deleteNodeImpl(t){const e=this.getPrevNode(t);e&&(e.next=t.next),t.next=null}popImpl(){this._head=this.getPrevNode(this._tail)}shiftImpl(){this._tail=this._head?.next||null}reverse(){let t=this._tail,e=this._head,s=0;for(;s<this._length;){const r=t?.next||null;t&&(t.next=e),s++,e=t,t=r}t&&(this._head=t,this._tail=t.next)}}class W extends D{constructor(t){super(t)}iterator(t=0){const e=this._head,s=this._tail;let r=this.getNodeByIndex(t);const i={current:()=>r.data,hasNext:()=>Boolean(r.next)&&r!==e,hasPrev:()=>Boolean(r.prev)&&r!==s,next:()=>{if(!i.hasNext())throw new p("Next element does not exist");return r=r.next,r.data},prev:()=>{if(!i.hasPrev())throw new p("Prev element does not exist");return r=r.prev,r.data}};return i}}class Q extends ${constructor(t){super(t)}iterator(t=0){const e=this._head;let s=this.getNodeByIndex(t);const r={current:()=>s.data,hasNext:()=>Boolean(s.next)&&s!==e,next:()=>{if(!r.hasNext())throw new p("Next element does not exist");return s=s.next,s.data}};return r}}const Y=(t,e=!1,s)=>{let r;if(e)switch(t){case z.DOUBLE:r=new W(s);break;case z.SINGLE:r=new Q(s)}else switch(t){case z.DOUBLE:r=new D(s);break;case z.SINGLE:r=new $(s)}return r};var J=/* @__PURE__ */(t=>(t.BST="Binary Search Tree",t.RANDOMIZED_BST="Randomized Binary Search Tree",t))(J||{}),Z=/* @__PURE__ */(t=>(t.IN_ORDER="IN_ORDER",t.PRE_ORDER="PRE_ORDER",t.POST_ORDER="POST_ORDER",t))(Z||{});class X{compare=(t,e)=>t>e;_head;_length;constructor(t){t&&(this.compare=t),this._head=null,this._length=0}length(){return this._length}}class H{_data;_left;_right;_parent;constructor(t){this._data=t,this._left=null,this._right=null,this._parent=null}get data(){return this._data}set data(t){this._data=t}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class tt extends H{_left;_right;_parent;constructor(t){super(t),this._left=null,this._right=null,this._parent=null}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class et extends X{_head;constructor(t){super(t),this._head=null}checkIsEmpty(){if(null===this._head)throw new R("Tree is empty")}updateLeftRightParents(t){t.left&&t.left.parent!==t&&(t.left.parent=t),t.right&&t.right.parent!==t&&(t.right.parent=t)}findNode(t){let e=this._head;for(;e&&e.data!==t;)e=this.compare(e.data,t)?e.left:e.right;return e}insertToLeaf(t){let e=null,s=this._head;for(;s;)e=s,s=this.compare(s.data,t.data)?s.left:s.right;t.parent=e,null===e?this._head=t:this.compare(e.data,t.data)?e.left=t:e.right=t,this._length++}join(t,e){return null===t?e:null===e?t:(e.left=this.join(t,e.left),e.left&&this.updateLeftRightParents(e),e)}max(){this.checkIsEmpty();let t=this._head;for(;t?.right;)t=t.right;return t.data}min(){this.checkIsEmpty();let t=this._head;for(;t?.left;)t=t.left;return t.data}insert(t){if(this.has(t))throw new g("Node already exists");const e=new tt(t);this.insertToLeaf(e)}has(t){const e=this.findNode(t);return e?.data===t}delete(t){if(!this.has(t))throw new p("Value does not exist in the tree");const e=(t,s)=>{if(null===t)return t;if(t.data===s){const e=this.join(t.left,t.right);return e&&(e.parent=t.parent),e}return this.compare(t.data,s)?t.left=e(t.left,s):t.right=e(t.right,s),this.updateLeftRightParents(t),t};this._head=e(this._head,t),this._length--}subtree(t){const e=new et,s=this.findNode(t),r=new P,i=[];for(r.push(s);!r.isEmpty();){const t=r.pop();i.push(t),t?.left&&r.push(t.left),t?.right&&r.push(t.right)}return i.forEach(t=>{null!==t&&e.insert(t.data)}),e}traverse(t,e){this.checkIsEmpty();const s=[],r=void 0!==e?this.findNode(e):this._head;switch(t){case Z.IN_ORDER:this.storeInOrder(r,s);break;case Z.PRE_ORDER:this.storePreOrder(r,s);break;case Z.POST_ORDER:this.storePostOrder(r,s)}return s}storeInOrder(t,e){t&&(this.storeInOrder(t.left,e),e.push(t.data),this.storeInOrder(t.right,e))}storePreOrder(t,e){t&&(e.push(t.data),this.storePreOrder(t.left,e),this.storePreOrder(t.right,e))}storePostOrder(t,e){t&&(this.storePostOrder(t.left,e),this.storePostOrder(t.right,e),e.push(t.data))}height(){const t=e=>{if(null===e)return 0;const s=null===e.left?-1:t(e.left),r=null===e.right?-1:t(e.right);return(s>r?s:r)+1};return null===this._head?0:t(this._head)+1}}class st extends tt{_rank;_left;_right;_parent;constructor(t){super(t),this._rank=0,this._left=null,this._right=null,this._parent=null}get rank(){return this._rank}set rank(t){this._rank=t}get left(){return this._left}set left(t){this._left=t}get right(){return this._right}set right(t){this._right=t}get parent(){return this._parent}set parent(t){this._parent=t}}class rt extends et{_head;constructor(t){super(t),this._head=null}updateRank(t){t.rank=(t.right?.rank||0)+(t.left?.rank||0)+1}addCreatedNode(t,e=null){return t.rank=1,null!==e&&(t.parent=e),t}rotateNodeRight(t){const e=t.left;null!==e&&(t.left=e.right,null!==e.right&&(e.right.parent=t),e.parent=t.parent,null===t.parent?this._head=e:t===t.parent.right?t.parent.right=e:t.parent.left=e,e.right=t,t.parent=e,this.updateRank(t),this.updateRank(e))}rotateNodeLeft(t){const e=t.right;null!==e&&(t.right=e.left,null!==e.left&&(e.left.parent=t),e.parent=t.parent,null===t.parent?this._head=e:t===t.parent.left?t.parent.left=e:t.parent.right=e,e.left=t,t.parent=e,this.updateRank(t),this.updateRank(e))}join(t,e){return null===t?e:null===e?t:Math.random()<t.rank/(t.rank+e.rank)?(t.right=this.join(t.right,e),t.right&&this.updateLeftRightParents(t),this.updateRank(t),t):(e.left=this.join(t,e.left),e.left&&this.updateLeftRightParents(e),this.updateRank(e),e)}updateLeftRightParents(t){super.updateLeftRightParents(t),this.updateRank(t)}insertToRoot(t,e){const s=e=>{this.compare(e.data,t.data)?(null===e.left?e.left=this.addCreatedNode(t,e):s(e.left),this.rotateNodeRight(e)):(null===e.right?e.right=this.addCreatedNode(t,e):s(e.right),this.rotateNodeLeft(e))};null===this._head?this._head=this.addCreatedNode(t):s(e||this._head)}insertRandomly(t){const e=s=>{Math.random()<1/(s.rank+1)?this.insertToRoot(t,s):(s.rank=s.rank+1,this.compare(s.data,t.data)?null===s.left?s.left=this.addCreatedNode(t,s):e(s.left):null===s.right?s.right=this.addCreatedNode(t,s):e(s.right))};null===this._head?this._head=this.addCreatedNode(t):e(this._head)}insert(t){if(this.has(t))throw new g("Node already exists");const e=new st(t);this.insertRandomly(e)}delete(t){super.delete(t),this._length=this.length()}length(){return this._head?.rank||0}}const it=t=>{let e;switch(t){case J.BST:e=new et;break;case J.RANDOMIZED_BST:e=new rt}return e},ht=(t,e,s)=>{if(e!==s){const r=t[e];t[e]=t[s],t[s]=r}},nt=t=>{for(let e=0;e<t.length-1;e++)for(let s=0;s<t.length-1;s++)t[s]>t[s+1]&&ht(t,s,s+1);return t},at=t=>t.reduce((e,s,r)=>s<t[e]?r:e,0),ot=(t,e)=>e+at(t.slice(e)),lt=t=>{for(let e=0;e<t.length;e++){const s=ot(t,e);ht(t,s,e)}return t},ut=(t,e,s)=>{if(s>e){const r=Math.floor(e+(s-e)/2);ut(t,e,r),ut(t,r+1,s),((t,e,s,r)=>{const i=t.slice(e,r+1);let h=e,n=e,a=s+1;for(;n<=s&&a<=r;){const s=i[n-e],r=i[a-e];s<r?(t[h]=s,n++):(t[h]=r,a++),h++}for(;n<=s;)t[h]=i[n-e],h++,n++;for(;a<=r;)t[h]=i[a-e],h++,a++})(t,e,r,s)}},dt=t=>(ut(t,0,t.length-1),t),ct=t=>{for(let e=1;e<t.length;e++){const s=t[e];let r=e-1;for(;r>=0&&t[r]>s;)ht(t,r+1,r),r--;t[r+1]=s}return t},pt=t=>{const e=(t,s=0,r=t.length-1)=>{if(s<r){const i=((t,e,s)=>{const r=t[e];let i=e,h=s;for(;i<=h;){for(;t[h]>r;)h--;for(;t[i]<r;)i++;i<=h&&(ht(t,i,h),h--,i++)}return i})(t,s,r);e(t,s,i-1),e(t,i,r)}return t};return e(t)},gt=(t,e=3)=>Math.round(t*10**e)/10**e,_t=(t,e)=>Math.floor(Math.random()*(e-t))+t;export{F as BinaryHeap,et as BinarySearchTree,R as CollectionIsEmptyException,I as CollectionIsFullException,x as DirectedGraph,D as DoubleLinkedList,t as EDGE_EXISTS_STATE,e as EDGE_NOT_EXISTS_STATE,C as GraphIteratorBFS,S as GraphIteratorDFS,A as GraphIteratorDijkstra,o as IllegalArgumentException,c as IllegalStateException,k as IndexOutOfBoundsException,g as IsAlreadyExistsException,p as IsNotFoundException,W as IterableDoubleLinkedList,Q as IterableSingleLinkedList,q as PriorityQueue,P as Queue,rt as RandBinarySearchTree,$ as SingleLinkedList,B as Stack,w as UndirectedGraph,N as ValueOutOfRangeException,a as binarySearch,nt as bubbleSort,it as createBinaryTree,m as createGraph,y as createGraphFromMatrix,M as createGraphIterator,Y as createLinkedList,r as factorial,h as fibonacci,at as getMinIndex,ot as getMinIndexFromIndex,K as hasPath,ct as insertionSort,s as memoize,i as memoizedFactorial,n as memoizedFibonacci,dt as mergeSort,U as presenterAdjacencyLists,E as presenterAdjacencyMatrix,pt as quickSort,_t as randomizeNumberInRange,gt as roundNumber,lt as selectSort,j as shortestPath,ht as swapArrayItems,v as transposeDirectedGraph,u as transposeMatrix};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@raikuxq/alg-ds",
   "scripts": {
     "test": "jest",
-    "dev": "nodemon",
+    "dev": "nodemon --exec tsx src/index.ts",
     "build:lib": "rimraf ./lib && vite build",
     "build:dts": "dts-bundle-generator -o lib/index.d.ts src/index.ts --no-check --inline-declare-externals false --external-inlines @babel/types",
     "build:full": "yarn build:lib && yarn build:dts",
@@ -69,10 +69,11 @@
     "ts-node": "^10.9.2",
     "ts-node-esm": "^0.0.6",
     "typescript": "5.8.2",
+    "typescript-eslint": "^8.54.0",
     "vite": "^7.3.1",
     "vuepress": "^2.0.0-beta.48"
   },
   "dependencies": {},
-  "version": "2.0.0",
+  "version": "3.0.0",
   "sideEffects": false
 }