@raikuxq/alg-ds 1.1.6 → 1.2.1

package/README.md

@@ -2,50 +2,31 @@ Common algorithms and data structures.
 
 Written in TypeScript, tested with Jest.
 
+# Documentation
+Documentation app: [raikuxq-algorithms.netlify.app/guide](https://raikuxq-algorithms.netlify.app/guide)
+
 
 # Usage as package
 Install by using any of these commands:
 + `yarn add @raikuxq/alg-ds`
 + `npm install @raikuxq/alg-ds --save`
 
-## Import from root
-`import { <anything> } from '@raikuxq/alg-ds'`
-
-## Import from sub-paths
-### Data structures
-`import {Stack, Queue, SingleLinkedList, DoubleLinkedList, RandBinarySearchTree, BinarySearchTree, DirectedGraph, UndirectedGraph, LoopedArray, HashTable, } from '@raikuxq/alg-ds/lib/exports/data-structures'`
-### Sorting algorithms
-`import {bubbleSort, insertionSort, mergeSort, selectSort, quickSort} from '@raikuxq/alg-ds/lib/exports/data-structures `
-### Other algorithms
-`import {binarySearch, factorial, memoizedFactorial, memoizedFibonacci, fibonacci, transposeMatrix, GraphIteratorDFS, presenterAdjacencyLists, presenterAdjacencyMatrix, hasPath, shortestPath, DijkstraIterationStrategy, DFSIterationStrategy, BFSIterationStrategy, GraphIteratorBFS, GraphIteratorDijkstra, transposeDirectedGraph} from '@raikuxq/alg-ds/lib/exports/algorithms'`
-### Helpers
-`import {createGraph, createGraphFromMatrix, createBinaryTree, createLinkedList, generateRandomGraph} from '@raikuxq/alg-ds/lib/exports/helpers`
-### Utils
-`import {perf, getMinIndex, getMinIndexFromIndex, memoize, perfAsync, roundNumber, randomizeNumberInRange, swapArrayItems} from '@raikuxq/alg-ds/lib/exports/utils'`
-### Constants
-`import {EDGE_NOT_EXISTS_STATE, EDGE_EXISTS_STATE} from '@raikuxq/alg-ds/lib/exports/constants'`
-
-
 
 # Usage as repository
 
 Clone this repository and install dependencies by using `yarn` command.
-
-+ `yarn test` - run all tests via jest  
-
++ `yarn test` - run all tests via jest
 + `yarn dev` - run in dev mode via nodemon (src/index.ts is an entrypoint)
-
 + `yarn build` - compile ts sources into js files
-
 + `yarn start` - build and run in production mode
-
 + `yarn lint` - lint check via eslint
-
 + `yarn lint:fix` - fix source files via eslint
 
 
 # Navigation
 + [Algorithms](#algorithms)
+  + [Utils](#utils)
+  + [Math](#math)
   + [Sorting algorithms](#sorting-algorithms)
 + [Linear data structures](#linear-data-structures)
   + [Linked list](#linked-list)
@@ -53,35 +34,37 @@ Clone this repository and install dependencies by using `yarn` command.
   + [Stack](#stack)
   + [Queue](#queue)
 + [Non-linear data structures](#non-linear-data-structures)
-  + [Hash table](#hash-table)
+  + [HASH table](#hash-table)
   + [Graph](#graph)
   + [Binary tree](#binary-trees)
 
 
 # Algorithms
 
-## Uncategorized algorithms
-[memoize](src/algorithms/memoize.ts) — Memoization util function.
+## Utils
+[memoize](src/app/algorithms/memoize.ts) — Memoization util function.
 
-[binary-search](src/algorithms/binary-search.ts) [[ tests ](test/unit/algorithms/binary-search.test.ts)] — Binary searching algorithm. Time: O(log(n)).
+## Searching
+[binary-search](src/app/algorithms/binary-search.ts) [[ tests ](test/unit/algorithms/binary-search.test.ts)] — Binary searching algorithm. Time: O(log(n)).
 
-[factorial](src/algorithms/factorial.ts) [[ tests ](test/unit/algorithms/factorial.test.ts)] — Recursive O(n!) and memoized O(n) factorial implementation.
+## Math
+[factorial](src/app/algorithms/factorial.ts) [[ tests ](test/unit/algorithms/factorial.test.ts)] — Recursive O(n!) and memoized O(n) factorial implementation.
 
-[fibonacci](src/algorithms/fibonacci.ts) [[ tests ](test/unit/algorithms/fibonacci.test.ts)] — Recursive O(n!) and memoized O(n) factorial implementation.
+[fibonacci](src/app/algorithms/fibonacci.ts) [[ tests ](test/unit/algorithms/fibonacci.test.ts)] — Recursive O(n!) and memoized O(n) factorial implementation.
 
-[transpose-matrix](src/algorithms/transpose-matrix.ts) [[ tests ](test/unit/algorithms/transpose-matrix.test.ts)]  — Transpose N*N matrix util function.
+[transpose-matrix](src/app/algorithms/transpose-matrix.ts) [[ tests ](test/unit/algorithms/transpose-matrix.test.ts)]  — Transpose N*N matrix util function.
 
 
 ## Sorting algorithms
-[bubble-sort](src/algorithms/sorts/bubble-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n) best. Memory: O(1) worst.
+[bubble-sort](src/app/algorithms/sorts/bubble-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n) best. Memory: O(1) worst.
 
-[selection-sort](src/algorithms/sorts/select-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n^2) best. Memory: O(1) worst. 
+[selection-sort](src/app/algorithms/sorts/select-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n^2) best. Memory: O(1) worst. 
 
-[insertion-sort](src/algorithms/sorts/insertion-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n) best. Memory: O(1) worst. 
+[insertion-sort](src/app/algorithms/sorts/insertion-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n^2) avg, O(n) best. Memory: O(1) worst. 
 
-[merge-sort](src/algorithms/sorts/merge-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n*log(n)) worst, O(n*log(n)) avg, O(n*log(n)) best. Memory: O(n) worst. 
+[merge-sort](src/app/algorithms/sorts/merge-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n*log(n)) worst, O(n*log(n)) avg, O(n*log(n)) best. Memory: O(n) worst. 
 
-[quick-sort](src/algorithms/sorts/quick-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n*log(n)) avg, O(n*log(n)) best. Memory: O(1) worst. 
+[quick-sort](src/app/algorithms/sorts/quick-sort.ts) [[ tests ](test/unit/algorithms/sorts.test.ts)] — Time: O(n^2) worst, O(n*log(n)) avg, O(n*log(n)) best. Memory: O(1) worst. 
 
 
 
@@ -90,154 +73,154 @@ Clone this repository and install dependencies by using `yarn` command.
 # Linear data structures
 
 ### Interfaces
-[ILinearStorage](src/types/ILinearStorage.ts) — Contains common methods of linear data structures.
+[ILinearStorage](src/app/types/ILinearStorage.ts) — Contains common methods of linear data structures.
 
-[ILinearStorageRA](src/types/ILinearStorageRA.ts) — Allows random access (from end, from start, by index). 
-Extends [ILinearStorage](src/types/ILinearStorage.ts) interface.
+[ILinearStorageRA](src/app/types/ILinearStorageRA.ts) — Allows random access (from end, from start, by index). 
+Extends [ILinearStorage](src/app/types/ILinearStorage.ts) interface.
 
-[IConvertableToArray](src/types/IConvertableToArray.ts) — Contain methods for converting from/into array.
+[IConvertableToArray](src/app/types/IConvertableToArray.ts) — Contain methods for converting from/into array.
 
 
 ## Linked List
 
 ### Interfaces
-[ILinkedList](src/types/ILinkedList.ts) — Contains basic linked lists operations.
-Extends [ILinearStorageRA](src/types/ILinearStorageRA.ts) and [IConvertableToArray](src/types/IConvertableToArray.ts) interface.
+[ILinkedList](src/app/types/ILinkedList.ts) — Contains basic linked lists operations.
+Extends [ILinearStorageRA](src/app/types/ILinearStorageRA.ts) and [IConvertableToArray](src/app/types/IConvertableToArray.ts) interface.
 
 ### Implementation
-[AbstractLinkedList](src/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedList.ts) — Common logic for both single and double linked lists.
-Implements [ILinearStorageRA](src/types/ILinearStorageRA.ts) interface.
+[AbstractLinkedList](src/app/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedList.ts) — Common logic for both single and double linked lists.
+Implements [ILinearStorageRA](src/app/types/ILinearStorageRA.ts) interface.
 
-[SingleLinkedList](src/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.ts) 
+[SingleLinkedList](src/app/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.ts) 
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list.test.ts)
 — Extends abstract linked list with implementation of one-way linking. 
-Implements [IIterable](src/types/IIterable.ts) interface.
+Implements [IIterable](src/app/types/IIterable.ts) interface.
 
-[DoubleLinkedList](src/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList.ts) 
+[DoubleLinkedList](src/app/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList.ts) 
 [ [ tests ] ](test/unit/data-structures/linked-list/linked-list.test.ts)
 — Extends abstract linked list with implementation of two-way linking.
-Implements [IBiDirectIterable](src/types/IBiDirectIterable.ts) interface.
+Implements [IBiDirectIterable](src/app/types/IBiDirectIterable.ts) interface.
 
 
 ## Looped Array
 
 ### Interfaces
-[IArrayFacade](src/types/IArrayFacade.ts) — Contains basic array operations. 
-Extends [ILinearStorageRA](src/types/ILinearStorageRA.ts) interface. 
-Extends [IConvertableToArray](src/types/IConvertableToArray.ts) interface.
+[IArrayFacade](src/app/types/IArrayFacade.ts) — Contains basic array operations. 
+Extends [ILinearStorageRA](src/app/types/ILinearStorageRA.ts) interface. 
+Extends [IConvertableToArray](src/app/types/IConvertableToArray.ts) interface.
 
 ### Implementation
-[LoopedArray](src/data-structures/LoopedArray/LoopedArray.ts)[ [ tests ]](test/unit/data-structures/looped-array/looped-array.test.ts)
+[LoopedArray](src/app/data-structures/LoopedArray/LoopedArray.ts)[ [ tests ]](test/unit/data-structures/looped-array/looped-array.test.ts)
 — Overwrites data on capacity overflow.
 
 ## Stack
 
 ### Implementation
-[Stack](src/data-structures/Stack/Stack.ts) [[ tests ](test/unit/data-structures/stack/stack.test.ts)] 
-— LIFO data structure. Implements [ILinearStorage](src/types/ILinearStorage.ts) interface.
+[Stack](src/app/data-structures/Stack/Stack.ts) [[ tests ](test/unit/data-structures/stack/stack.test.ts)] 
+— LIFO data structure. Implements [ILinearStorage](src/app/types/ILinearStorage.ts) interface.
 
 ## Queue
 
 ### Implementation
-[Queue](src/data-structures/Queue/Queue.ts) [[ tests ](test/unit/data-structures/queue/queue.test.ts)] 
-— FIFO data structure. Implements [ILinearStorage](src/types/ILinearStorage.ts) interface.
+[Queue](src/app/data-structures/Queue/Queue.ts) [[ tests ](test/unit/data-structures/queue/queue.test.ts)] 
+— FIFO data structure. Implements [ILinearStorage](src/app/types/ILinearStorage.ts) interface.
   
 
 
 # Non linear data structures
 
-## Hash Table
+## HASH Table
 ### Interfaces
-[IKeyValueStorage](src/types/IKeyValueStorage.ts) — Contains basic key-value storages operations.
+[IKeyValueStorage](src/app/types/IKeyValueStorage.ts) — Contains basic key-value storages operations.
 
 ### Implementation
-[HashTableNode](src/data-structures/HashTable/HashTableNode.ts) — Contains key, data and isDeleted properties.
+[HashTableNode](src/app/data-structures/HashTable/HashTableNode.ts) — Contains key, data and isDeleted properties.
 
-[HashTable](src/data-structures/HashTable/HashTable.ts)  [ [ tests ] ](test/unit/data-structures/hash-table/hash-table.test.ts) — Implementation of open addressing hash table using quadratic probing
+[HashTable](src/app/data-structures/HashTable/HashTable.ts)  [ [ tests ] ](test/unit/data-structures/hash-table/hash-table.test.ts) — Implementation of open addressing hash table using quadratic probing
 
 
 
 ## Graph
 ### Interfaces
-[IGraph](src/types/IGraph.ts) — Contains basic graph operations.
+[IGraph](src/app/types/IGraph.ts) — Contains basic graph operations.
 
-[IGraphIterator](src/types/IGraphIterator.ts) — Extends default iterator with init and getPath methods.
+[IGraphIterator](src/app/types/IGraphIterator.ts) — Extends default iterator with init and getPath methods.
 
-[IGraphIterationStrategy](src/types/IGraphIterationStrategy.ts) — Iteration strategies which are used in shortest-path, has-path.
+[IGraphIterationStrategy](src/app/types/IGraphIterationStrategy.ts) — Iteration strategies which are used in shortest-path, has-path.
 
 ### Implementation
-[GraphEdge](src/data-structures/Graph/GraphEdge.ts) — Contains from/to links and edge weight.
+[GraphEdge](src/app/data-structures/Graph/GraphEdge.ts) — Contains from/to links and edge weight.
 
-[AbstractGraph](src/data-structures/Graph/AbstractGraph.ts) — Common logic for both directed and undirected graphs.
+[AbstractGraph](src/app/data-structures/Graph/AbstractGraph.ts) — Common logic for both directed and undirected graphs.
 
 
-[DirectedGraph](src/data-structures/Graph/DirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
+[DirectedGraph](src/app/data-structures/Graph/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/data-structures/Graph/UndirectedGraph.ts) [ [ tests ] ](test/unit/data-structures/graph/graph.test.ts) 
+[UndirectedGraph](src/app/data-structures/Graph/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/data-structures/Graph/iterator/GraphIteratorBFS.ts) 
+[BreadthFirstSearchIterator](src/app/algorithms/graph/iterator/GraphIteratorBFS.ts) 
 — Traversal method for unweighted graphs, built on queue.
 
-[DepthFirstSearchIterator](src/data-structures/Graph/iterator/GraphIteratorDFS.ts)
+[DepthFirstSearchIterator](src/app/algorithms/graph/iterator/GraphIteratorDFS.ts)
 — Traversal method for unweighted graphs, built on stack.
 
-[DijkstraMethodIterator](src/data-structures/Graph/iterator/GraphIteratorDijkstra.ts)
+[DijkstraMethodIterator](src/app/algorithms/graph/iterator/GraphIteratorDijkstra.ts)
 — Traversal method for weighted graphs, built on finding the minimal cost.
 
 
 ### Graph Presenter
-[presenter-adjacency-lists](src/data-structures/Graph/presenter/presenterAdjacencyLists.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.lists.test.ts)] 
+[presenter-adjacency-lists](src/app/algorithms/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/data-structures/Graph/presenter/presenterAdjacencyMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.presenter.matrix.test.ts)]
+[presenter-adjacency-matrix](src/app/algorithms/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/data-structures/Graph/searching/hasPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.has-path.test.ts)] 
+[has-path (BFS/DFS)](src/app/algorithms/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/data-structures/Graph/searching/shortestPath.ts)  [[ tests ](test/unit/data-structures/graph/graph.shortest-path.test.ts)] 
+[shortest-path (BFS/Dijkstra)](src/app/algorithms/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/helpers/createGraphFromMatrix.ts)  [[ tests ](test/unit/data-structures/graph/graph.create-from-matrix.test.ts)] 
+[create-graph-from-matrix](src/app/data-structures/Graph/_helpers/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/data-structures/Graph/transposing/transposeDirectedGraph.ts)  [ [ tests ](test/unit/data-structures/graph/graph.transpose.test.ts)]
+[transpose-directed-graph](src/app/algorithms/graph/transposing/transposeDirectedGraph.ts)  [ [ tests ](test/unit/data-structures/graph/graph.transpose.test.ts)]
 — Transpose a directed graph (undirected graphs are symmetrical already).
 
 
 
 ## Binary trees
-[IBinaryTree](src/types/IBinaryTree.ts) — Contains basic binary tree operations.
+[IBinaryTree](src/app/types/IBinaryTree.ts) — Contains basic binary tree operations.
 
 ### Implementation
 
-[AbstractBinaryNode](src/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.ts) — Contains left/right/parent links and node data.
+[AbstractBinaryNode](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.ts) — Contains left/right/parent links and node data.
 
-[AbstractBinaryTree](src/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts) — Common logic for all types of binary trees.
+[AbstractBinaryTree](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts) — Common logic for all types of binary trees.
 
   
-[BinarySearchNode](src/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts) — Same as abstract binary node.
+[BinarySearchNode](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts) — Same as abstract binary node.
 
-[BinarySearchTree](src/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts) — Implementation of unbalanced binary search tree. 
+[BinarySearchTree](src/app/data-structures/BinaryTree/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/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts).
+Extends [AbstractSearchTree](src/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.ts).
 
 
 
-[RandBinarySearchNode](src/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.ts) — Have a rank attribute. 
-Extends [BinarySearchNode](src/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts).
+[RandBinarySearchNode](src/app/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.ts) — Have a rank attribute. 
+Extends [BinarySearchNode](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts).
 
-[RandBinarySearchTree](src/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree.ts) 
+[RandBinarySearchTree](src/app/data-structures/BinaryTree/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/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts).
+INSERTION have a 1/N+1 probability of inserting into root. 
+Extends [BinarySearchTree](src/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts).

package/lib/app/algorithms/binary-search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+export declare const binarySearch: (elements: Array<number>, searchElement: number) => number | null;

package/lib/app/algorithms/binary-search.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearch = void 0;
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+exports.binarySearch = function (elements, searchElement) {
+    var length = elements.length;
+    var leftIndex = 0;
+    var rightIndex = length - 1;
+    while (leftIndex <= rightIndex) {
+        var midIndex = Math.ceil((leftIndex + rightIndex) / 2);
+        var midEl = elements[midIndex];
+        if (searchElement == midEl) {
+            return midIndex;
+        }
+        else if (midEl > searchElement) {
+            rightIndex = midIndex - 1;
+        }
+        else if (midEl < searchElement) {
+            leftIndex = midIndex + 1;
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmluYXJ5LXNlYXJjaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvYWxnb3JpdGhtcy9iaW5hcnktc2VhcmNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7R0FHRztBQUNVLFFBQUEsWUFBWSxHQUFHLFVBQzFCLFFBQXVCLEVBQ3ZCLGFBQXFCO0lBRXJCLElBQU0sTUFBTSxHQUFXLFFBQVEsQ0FBQyxNQUFNLENBQUM7SUFFdkMsSUFBSSxTQUFTLEdBQUcsQ0FBQyxDQUFDO0lBQ2xCLElBQUksVUFBVSxHQUFXLE1BQU0sR0FBRyxDQUFDLENBQUM7SUFFcEMsT0FBTyxTQUFTLElBQUksVUFBVSxFQUFFO1FBQzlCLElBQU0sUUFBUSxHQUFXLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDakUsSUFBTSxLQUFLLEdBQVcsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBRXpDLElBQUksYUFBYSxJQUFJLEtBQUssRUFBRTtZQUMxQixPQUFPLFFBQVEsQ0FBQztTQUNqQjthQUFNLElBQUksS0FBSyxHQUFHLGFBQWEsRUFBRTtZQUNoQyxVQUFVLEdBQUcsUUFBUSxHQUFHLENBQUMsQ0FBQztTQUMzQjthQUFNLElBQUksS0FBSyxHQUFHLGFBQWEsRUFBRTtZQUNoQyxTQUFTLEdBQUcsUUFBUSxHQUFHLENBQUMsQ0FBQztTQUMxQjtLQUNGO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDLENBQUMifQ==

package/lib/app/algorithms/factorial.d.ts

@@ -0,0 +1,9 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+/**
+ * Time complexity: O(n!)
+ */
+export declare const factorial: (x: number) => number;
+/**
+ * Time complexity: O(n) - due to caching
+ */
+export declare const memoizedFactorial: FnToMemoize<number, number>;

package/lib/app/algorithms/factorial.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizedFactorial = exports.factorial = void 0;
+var memoize_1 = require("./memoize");
+/**
+ * Time complexity: O(n!)
+ */
+exports.factorial = function (x) {
+    return x > 1 ? x * exports.factorial(x - 1) : x;
+};
+/**
+ * Time complexity: O(n) - due to caching
+ */
+exports.memoizedFactorial = memoize_1.memoize(function (n) {
+    return n > 1 ? n * exports.memoizedFactorial(n - 1) : n;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFjdG9yaWFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9hbGdvcml0aG1zL2ZhY3RvcmlhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxQ0FBb0M7QUFHcEM7O0dBRUc7QUFDVSxRQUFBLFNBQVMsR0FBRyxVQUFDLENBQVM7SUFDakMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsaUJBQVMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMxQyxDQUFDLENBQUM7QUFFRjs7R0FFRztBQUNVLFFBQUEsaUJBQWlCLEdBQWdDLGlCQUFPLENBQ25FLFVBQUMsQ0FBUztJQUNSLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLHlCQUFpQixDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2xELENBQUMsQ0FDRixDQUFDIn0=

package/lib/app/algorithms/fibonacci.d.ts

@@ -0,0 +1,9 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+/**
+ * Time complexity: O(n!)
+ */
+export declare const fibonacci: (n: number) => number;
+/**
+ * Time complexity: O(n) - due to caching
+ */
+export declare const memoizedFibonacci: FnToMemoize<number, number>;

package/lib/app/algorithms/fibonacci.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizedFibonacci = exports.fibonacci = void 0;
+var memoize_1 = require("./memoize");
+/**
+ * Time complexity: O(n!)
+ */
+exports.fibonacci = function (n) {
+    return n > 1 ? exports.fibonacci(n - 1) + exports.fibonacci(n - 2) : n;
+};
+/**
+ * Time complexity: O(n) - due to caching
+ */
+exports.memoizedFibonacci = memoize_1.memoize(function (n) {
+    return n > 1 ? exports.memoizedFibonacci(n - 1) + exports.memoizedFibonacci(n - 2) : n;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlib25hY2NpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9hbGdvcml0aG1zL2ZpYm9uYWNjaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxxQ0FBb0M7QUFFcEM7O0dBRUc7QUFDVSxRQUFBLFNBQVMsR0FBRyxVQUFDLENBQVM7SUFDakMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxpQkFBUyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxpQkFBUyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ3pELENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ1UsUUFBQSxpQkFBaUIsR0FBZ0MsaUJBQU8sQ0FDbkUsVUFBQyxDQUFTO0lBQ1IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyx5QkFBaUIsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcseUJBQWlCLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDekUsQ0FBQyxDQUNGLENBQUMifQ==

package/lib/app/algorithms/graph/iterator/AbstractGraphIterator.d.ts

@@ -0,0 +1,35 @@
+import IGraphIterator from "../../../types/IGraphIterator";
+import IGraph from "../../../types/IGraph";
+export default abstract class AbstractGraphIterator<T> implements IGraphIterator<T> {
+    protected readonly graph: IGraph<T>;
+    protected readonly visited: Map<T, boolean>;
+    protected readonly parents: Map<T, T>;
+    /**
+     * Creates empty instance
+     */
+    protected constructor(graph: IGraph<T>);
+    protected abstract currentImpl(): T;
+    protected abstract nextImpl(): T;
+    protected abstract initIteratorImpl(from: T): void;
+    protected abstract hasNextImpl(): boolean;
+    /**
+     * @inheritDoc
+     */
+    initIterator(from: T): void;
+    /**
+     * @inheritDoc
+     */
+    hasNext(): boolean;
+    /**
+     * @inheritDoc
+     */
+    next(): T;
+    /**
+     * @inheritDoc
+     */
+    current(): T;
+    /**
+     * @inheritDoc
+     */
+    getPath(from: T, to: T): Array<T>;
+}

package/lib/app/algorithms/graph/iterator/AbstractGraphIterator.js

@@ -0,0 +1,83 @@
+"use strict";
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var IsNotFoundException_1 = require("../../../exceptions/IsNotFoundException");
+var IllegalStateException_1 = require("../../../exceptions/base/IllegalStateException");
+var AbstractGraphIterator = /** @class */ (function () {
+    /**
+     * Creates empty instance
+     */
+    function AbstractGraphIterator(graph) {
+        this.graph = graph;
+        this.visited = new Map();
+        this.parents = new Map();
+    }
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.initIterator = function (from) {
+        if (!this.graph.hasVertex(from)) {
+            throw new IsNotFoundException_1.default("Start vertex does not exist");
+        }
+        this.initIteratorImpl(from);
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.hasNext = function () {
+        return this.hasNextImpl();
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.next = function () {
+        if (!this.hasNext()) {
+            throw new IllegalStateException_1.default("Next element does not exist");
+        }
+        return this.nextImpl();
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.current = function () {
+        try {
+            return this.currentImpl();
+        }
+        catch (e) {
+            throw new IllegalStateException_1.default("Current element does not exist");
+        }
+    };
+    /**
+     * @inheritDoc
+     */
+    AbstractGraphIterator.prototype.getPath = function (from, to) {
+        var path = new Array();
+        var isLinkedDirectly = this.graph.hasEdge(from, to);
+        var currentVertex = this.parents.get(to);
+        if (isLinkedDirectly) {
+            return [from, to];
+        }
+        else {
+            while (currentVertex) {
+                if (currentVertex === from) {
+                    break;
+                }
+                path.push(currentVertex);
+                currentVertex = this.parents.get(currentVertex);
+            }
+            if (path.length === 0) {
+                throw new IllegalStateException_1.default("There is no path found");
+            }
+            return __spreadArrays([from], path.reverse(), [to]);
+        }
+    };
+    return AbstractGraphIterator;
+}());
+exports.default = AbstractGraphIterator;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/algorithms/graph/iterator/GraphIteratorBFS.d.ts

@@ -0,0 +1,28 @@
+import IGraph from "../../../types/IGraph";
+import AbstractGraphIterator from "./AbstractGraphIterator";
+/**
+ * Breadth first graph traversal
+ */
+export default class GraphIteratorBFS<T> extends AbstractGraphIterator<T> {
+    private readonly queue;
+    /**
+     * @inheritDoc
+     */
+    constructor(graph: IGraph<T>);
+    /**
+     * @inheritDoc
+     */
+    protected currentImpl(): T;
+    /**
+      @inheritDoc
+     */
+    initIteratorImpl(startVertex: T): void;
+    /**
+     * @inheritDoc
+     */
+    hasNextImpl(): boolean;
+    /**
+     * @inheritDoc
+     */
+    protected nextImpl(): T;
+}

package/lib/app/algorithms/graph/iterator/GraphIteratorBFS.js

@@ -0,0 +1,70 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Queue_1 = require("../../../data-structures/Queue/Queue");
+var AbstractGraphIterator_1 = require("./AbstractGraphIterator");
+/**
+ * Breadth first graph traversal
+ */
+var GraphIteratorBFS = /** @class */ (function (_super) {
+    __extends(GraphIteratorBFS, _super);
+    /**
+     * @inheritDoc
+     */
+    function GraphIteratorBFS(graph) {
+        var _this = _super.call(this, graph) || this;
+        _this.queue = new Queue_1.default();
+        return _this;
+    }
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.currentImpl = function () {
+        return this.queue.peek();
+    };
+    /**
+      @inheritDoc
+     */
+    GraphIteratorBFS.prototype.initIteratorImpl = function (startVertex) {
+        this.queue.push(startVertex);
+        this.visited.set(startVertex, true);
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.hasNextImpl = function () {
+        return !this.queue.isEmpty();
+    };
+    /**
+     * @inheritDoc
+     */
+    GraphIteratorBFS.prototype.nextImpl = function () {
+        var _this = this;
+        var next = this.queue.pop();
+        var nextNeighbors = this.graph.getVertexNeighbors(next);
+        nextNeighbors.forEach(function (neighbor) {
+            var isNotVisited = !_this.visited.get(neighbor);
+            if (isNotVisited) {
+                _this.queue.push(neighbor);
+                _this.visited.set(neighbor, true);
+                _this.parents.set(neighbor, next);
+            }
+        });
+        return next;
+    };
+    return GraphIteratorBFS;
+}(AbstractGraphIterator_1.default));
+exports.default = GraphIteratorBFS;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiR3JhcGhJdGVyYXRvckJGUy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvYWxnb3JpdGhtcy9ncmFwaC9pdGVyYXRvci9HcmFwaEl0ZXJhdG9yQkZTLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDhEQUF5RDtBQUV6RCxpRUFBNEQ7QUFFNUQ7O0dBRUc7QUFDSDtJQUFpRCxvQ0FBd0I7SUFHdkU7O09BRUc7SUFDSCwwQkFBbUIsS0FBZ0I7UUFBbkMsWUFDRSxrQkFBTSxLQUFLLENBQUMsU0FFYjtRQURDLEtBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxlQUFLLEVBQUUsQ0FBQzs7SUFDM0IsQ0FBQztJQUVEOztPQUVHO0lBQ08sc0NBQVcsR0FBckI7UUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDM0IsQ0FBQztJQUVEOztPQUVHO0lBQ0ksMkNBQWdCLEdBQXZCLFVBQXdCLFdBQWM7UUFDcEMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDN0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNJLHNDQUFXLEdBQWxCO1FBQ0UsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVEOztPQUVHO0lBQ08sbUNBQVEsR0FBbEI7UUFBQSxpQkFlQztRQWRDLElBQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxFQUFFLENBQUM7UUFDOUIsSUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUUxRCxhQUFhLENBQUMsT0FBTyxDQUFDLFVBQUMsUUFBUTtZQUM3QixJQUFNLFlBQVksR0FBRyxDQUFDLEtBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1lBRWpELElBQUksWUFBWSxFQUFFO2dCQUNoQixLQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDMUIsS0FBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO2dCQUNqQyxLQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7YUFDbEM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUNILHVCQUFDO0FBQUQsQ0FBQyxBQXBERCxDQUFpRCwrQkFBcUIsR0FvRHJFIn0=