@raikuxq/alg-ds 1.2.5 → 2.0.0

package/lib/index.d.ts

@@ -1,3 +1,1216 @@
-/**
- * Write your code here
- */
+// Generated by dts-bundle-generator v9.5.1
+
+export type FnToMemoize<Key, Value> = (...args: Array<Key>) => Value;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+export declare const binarySearch: (elements: Array<number>, searchElement: number) => number | null;
+export type TypeArrayMatrix = Array<Array<number>>;
+/**
+ * Will flips a matrix over its diagonal
+ * @throws {IllegalArgumentException} when array is not a matrix
+ */
+export declare const transposeMatrix: (matrix: TypeArrayMatrix) => TypeArrayMatrix;
+export interface IGraph<T> {
+	weight(): number;
+	vertices(): Array<T>;
+	verticesCount(): number;
+	edgesCount(): number;
+	addVertex(data: T): this;
+	removeVertex(data: T): this;
+	hasVertex(data: T): boolean;
+	getVertexNeighbors(data: T): Array<T>;
+	addEdge(from: T, to: T, weight?: number): this;
+	removeEdge(from: T, to: T): this;
+	hasEdge(from: T, to: T): boolean;
+	getEdgeWeight(from: T, to: T): number;
+}
+export declare const transposeDirectedGraph: <T>(sourceGraph: IGraph<T>) => IGraph<T>;
+export interface IIterator<T> {
+	/**
+	 * Will do one iteration and returns next item value
+	 */
+	next(): T;
+	/**
+	 * Will returns current value
+	 */
+	current(): T;
+	/**
+	 * Check if next element exists
+	 */
+	hasNext(): boolean;
+}
+export interface IGraphIterator<T> extends IIterator<T> {
+	/**
+	 * Get path which passed by iterator between two vertices
+	 */
+	getPath(from: T, to: T): Array<T>;
+	/**
+	 * Initialize iterator by passing start vertex
+	 */
+	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>;
+	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
+	 * @throws {IsNotFoundException} when start vertex was not found
+	 */
+	initIterator(from: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	hasNext(): boolean;
+	/**
+	 * @inheritDoc
+	 * @throws {IllegalStateException} when next element does not exist
+	 */
+	next(): T;
+	/**
+	 * @inheritDoc
+	 * @throws {IllegalStateException} when current element does not exist
+	 */
+	current(): T;
+	/**
+	 * @inheritDoc
+	 * @throws {IllegalStateException} when there is no path between given vertices
+	 */
+	getPath(from: T, to: T): Array<T>;
+}
+/**
+ * Breadth first graph traversal
+ */
+export declare 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;
+}
+/**
+ * Deep first graph traversal
+ */
+export declare class GraphIteratorDFS<T> extends AbstractGraphIterator<T> {
+	private readonly stack;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(graph: IGraph<T>);
+	/**
+	 * @inheritDoc
+	 */
+	hasNextImpl(): boolean;
+	/**
+	 @inheritDoc
+	 */
+	initIteratorImpl(startVertex: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	currentImpl(): T;
+	/**
+	 * @inheritDoc
+	 */
+	nextImpl(): T;
+}
+/**
+ * Dijkstra method graph traversal
+ */
+export declare class GraphIteratorDijkstra<T> extends AbstractGraphIterator<T> {
+	private readonly costs;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(graph: IGraph<T>);
+	/**
+	 * Get not visited vertex with minimal cost
+	 */
+	private getClosestNotVisited;
+	/**
+	 * @inheritDoc
+	 */
+	initIteratorImpl(startVertex: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	hasNextImpl(): boolean;
+	/**
+	 * @inheritDoc
+	 */
+	currentImpl(): T;
+	/**
+	 * @inheritDoc
+	 */
+	nextImpl(): 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;
+/**
+ * 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>;
+/**
+ * Get graph adjacency matrix N x N
+ *
+ * @example
+ *
+ * Directed graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John []
+ *
+ * Its matrix:
+ *       |  Bob  | Maria |  John |
+ * Bob   |   0   |   1   |   0   |
+ * Maria |   1   |   0   |   1   |
+ * John  |   0   |   0   |   0   |
+ *
+ * @example
+ *
+ * Undirected graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John [Maria]
+ *
+ * Its matrix:
+ *       |  Bob  | Maria |  John |
+ * Bob   |   0   |   1   |   0   |
+ * Maria |   1   |   0   |   1   |
+ * John  |   0   |   1   |   0   |
+ */
+export declare const presenterAdjacencyMatrix: <T>(graph: IGraph<T>) => TypeArrayMatrix;
+/**
+ * Get graph adjacency list
+ *
+ * @example
+ *
+ * Directed graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - John []
+ *
+ * @example
+ *
+ * Undirected graph:
+ * - Bob [Maria]
+ * - Maria [Bob, John]
+ * - 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"
+}
+export interface ILinearStorage<T> {
+	peek(): T;
+	push(value: T): void;
+	pop(): T;
+	has(value: T): boolean;
+	isEmpty(): boolean;
+	isFull(): boolean;
+	length(): number;
+	clear(): void;
+	reverse(): void;
+}
+/**
+ * Interface extends default linear storage with methods that allows read/write operations for all storage elements
+ * RA - randomly accessible
+ */
+export interface ILinearStorageRA<T> extends ILinearStorage<T> {
+	peekFromStart(): T;
+	peekByIndex(index: number): T;
+	unshift(value: T): void;
+	pushFromIndex(value: T, fromIndex: number): void;
+	shift(): T;
+	deleteFromIndex(fromIndex: number): T;
+}
+export interface IConvertableToArray<T> {
+	pushFromArray(elements: Array<T>): void;
+	getAsArray(): Array<T>;
+}
+export interface ILinkedList<T> extends ILinearStorageRA<T>, IConvertableToArray<T> {
+}
+export declare const createLinkedList: <T>(type: EnumLinkedListType, isIterable?: boolean, capacity?: number) => ILinkedList<T>;
+declare enum EnumBinarySearchTreeType {
+	BST = "Binary Search Tree",
+	RANDOMIZED_BST = "Randomized Binary Search Tree"
+}
+declare enum EnumTreeTraversalType {
+	IN_ORDER = "IN_ORDER",
+	PRE_ORDER = "PRE_ORDER",
+	POST_ORDER = "POST_ORDER"
+}
+export interface IBinaryTree<T> {
+	has(value: T): boolean;
+	insert(value: T): void;
+	delete(value: T): void;
+	subtree(value: T): IBinaryTree<T>;
+	max(): T;
+	min(): T;
+	length(): number;
+	height(): number;
+	traverse(type: EnumTreeTraversalType): Array<T>;
+}
+/**
+ * Returns binary tree by type
+ */
+export declare const createBinaryTree: <T>(type: EnumBinarySearchTreeType) => IBinaryTree<T>;
+/**
+ * Returns graph by type
+ */
+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
+ */
+export declare class Queue<T> implements ILinearStorage<T> {
+	private readonly _list;
+	/**
+	 * Create a queue instance
+	 */
+	constructor(capacity?: number);
+	/**
+	 * Get first element in queue (without deleting)
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	peek(): T;
+	/**
+	 * Add element to queue
+	 * @throws {CollectionIsFullException} when list is full
+	 */
+	push(item: T): void;
+	/**
+	 * Delete first element in queue
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	pop(): T;
+	/**
+	 * Check if element exists in list
+	 */
+	has(item: T): boolean;
+	/**
+	 * Is queue empty
+	 */
+	isEmpty(): boolean;
+	/**
+	 * Is stack full
+	 */
+	isFull(): boolean;
+	/**
+	 * Remove all elements in queue
+	 */
+	clear(): void;
+	/**
+	 * Queue length
+	 */
+	length(): number;
+	/**
+	 * Reverse queue
+	 */
+	reverse(): void;
+}
+/**
+ * LIFO data structure
+ */
+export declare class Stack<T> implements ILinearStorage<T> {
+	private readonly _list;
+	/**
+	 * Create a stack instance
+	 */
+	constructor(capacity?: number);
+	/**
+	 * Get stack top element
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	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;
+}
+/**
+ * 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();
+	/**
+	 * @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;
+}
+/**
+ * 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;
+}
+export type FnCompareTwo<T> = (firstItem: T, secondItem: T) => boolean;
+declare abstract class AbstractBinaryNode<T> {
+	protected _data: T;
+	protected _left: AbstractBinaryNode<T> | null;
+	protected _right: AbstractBinaryNode<T> | null;
+	protected _parent: AbstractBinaryNode<T> | null;
+	protected constructor(initialData: T);
+	get data(): T;
+	set data(value: T);
+	get left(): AbstractBinaryNode<T> | null;
+	set left(value: AbstractBinaryNode<T> | null);
+	get right(): AbstractBinaryNode<T> | null;
+	set right(value: AbstractBinaryNode<T> | null);
+	get parent(): AbstractBinaryNode<T> | null;
+	set parent(value: AbstractBinaryNode<T> | null);
+}
+declare abstract class AbstractBinaryTree<T> implements IBinaryTree<T> {
+	/**
+	 * Function that checks is node A better
+	 * @default a > b
+	 * @example 5 > 4
+	 * @example 'abc' > 'aba'
+	 */
+	protected compare: FnCompareTwo<T>;
+	protected _head: AbstractBinaryNode<T> | null;
+	protected _length: number;
+	/**
+	 *
+	 * @param fnCompare
+	 * @protected
+	 */
+	protected constructor(fnCompare?: FnCompareTwo<T>);
+	/**
+	 * Returns nodes count in the entire tree
+	 */
+	length(): number;
+	/**
+	 * Will create new node and place it according to the type of tree rules
+	 */
+	abstract insert(value: T): void;
+	/**
+	 * Will check if tree has a node with given data
+	 */
+	abstract has(value: T): boolean;
+	/**
+	 * Will delete node from the tree and restructure it
+	 */
+	abstract delete(value: T): void;
+	/**
+	 * Max value of the tree
+	 */
+	abstract max(): T;
+	/**
+	 * Min value of the tree
+	 */
+	abstract min(): T;
+	/**
+	 * Returns same class instance with new head node
+	 */
+	abstract subtree(value: T): IBinaryTree<T>;
+	/**
+	 * Returns the highest branch length in the tree
+	 */
+	abstract height(): number;
+	/**
+	 * In-order/Pre-order/Post-order traversing of the tree
+	 */
+	abstract traverse(type: EnumTreeTraversalType): Array<T>;
+}
+declare class BinarySearchNode<T> extends AbstractBinaryNode<T> {
+	protected _left: BinarySearchNode<T> | null;
+	protected _right: BinarySearchNode<T> | null;
+	protected _parent: BinarySearchNode<T> | null;
+	constructor(initialData: T);
+	get left(): BinarySearchNode<T> | null;
+	set left(value: BinarySearchNode<T> | null);
+	get right(): BinarySearchNode<T> | null;
+	set right(value: BinarySearchNode<T> | null);
+	get parent(): BinarySearchNode<T> | null;
+	set parent(value: BinarySearchNode<T> | null);
+}
+/**
+ * Unbalanced binary search tree implementation
+ */
+export declare class BinarySearchTree<T> extends AbstractBinaryTree<T> {
+	/**
+	 * Override types
+	 */
+	protected _head: BinarySearchNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(fnCompare?: FnCompareTwo<T>);
+	/**
+	 *
+	 * @throws {CollectionIsEmptyException} when tree is empty
+	 */
+	protected checkIsEmpty(): void;
+	/**
+	 * Will update left and right links parent with current node
+	 */
+	protected updateLeftRightParents(node: BinarySearchNode<T>): void;
+	/**
+	 * Will return node instance by its data
+	 */
+	protected findNode(value: T): BinarySearchNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	protected insertToLeaf(createdNode: BinarySearchNode<T>): void;
+	/**
+	 * Will join two trees into one   */
+	protected join(treeLeft: BinarySearchNode<T> | null, treeRight: BinarySearchNode<T> | null): BinarySearchNode<T> | null;
+	/**
+	 * @inheritDoc
+	 * @throws {CollectionIsEmptyException} when tree is empty
+	 */
+	max(): T;
+	/**
+	 * @inheritDoc
+	 * @throws {CollectionIsEmptyException} when tree is empty
+	 */
+	min(): T;
+	/**
+	 * @inheritDoc
+	 * @throws {IsAlreadyExistsException} when node already exists
+	 */
+	insert(value: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	has(value: T): boolean;
+	/**
+	 * @inheritDoc
+	 * @throws {IsNotFoundException} when node was not found
+	 */
+	delete(value: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	subtree(value: T): IBinaryTree<T>;
+	/**
+	 * @inheritDoc
+	 * @throws {CollectionIsEmptyException} when tree is empty
+	 */
+	traverse(type: EnumTreeTraversalType, from?: T): Array<T>;
+	/**
+	 * Calc max height of the largest branch of the tree
+	 */
+	height(): number;
+}
+declare class RandBinarySearchNode<T> extends BinarySearchNode<T> {
+	private _rank;
+	protected _left: RandBinarySearchNode<T> | null;
+	protected _right: RandBinarySearchNode<T> | null;
+	protected _parent: RandBinarySearchNode<T> | null;
+	constructor(initialData: T);
+	get rank(): number;
+	set rank(value: number);
+	get left(): RandBinarySearchNode<T> | null;
+	set left(value: RandBinarySearchNode<T> | null);
+	get right(): RandBinarySearchNode<T> | null;
+	set right(value: RandBinarySearchNode<T> | null);
+	get parent(): RandBinarySearchNode<T> | null;
+	set parent(value: RandBinarySearchNode<T> | null);
+}
+/**
+ * Randomized binary search tree implementation
+ */
+export declare class RandBinarySearchTree<T> extends BinarySearchTree<T> {
+	/**
+	 * Override types
+	 */
+	protected _head: RandBinarySearchNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(fnCompare?: FnCompareTwo<T>);
+	/**
+	 * Will update node rank by summing left and right subtrees tanks and itself rank (1)
+	 */
+	private updateRank;
+	/**
+	 * Will set rank and parent attributes and update tree length
+	 */
+	private addCreatedNode;
+	/**
+	 * Will rotate node to the right side
+	 */
+	private rotateNodeRight;
+	/**
+	 * Will rotate node to the left side
+	 */
+	private rotateNodeLeft;
+	/**
+	 * @inheritDoc
+	 */
+	protected join(treeLeft: RandBinarySearchNode<T> | null, treeRight: RandBinarySearchNode<T> | null): RandBinarySearchNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	protected updateLeftRightParents(node: RandBinarySearchNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected insertToRoot(createdNode: RandBinarySearchNode<T>, fromNode?: RandBinarySearchNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected insertRandomly(createdNode: RandBinarySearchNode<T>): void;
+	/**
+	 * @inheritDoc
+	 * @throws {IsAlreadyExistsException} when node already exists
+	 */
+	insert(value: T): void;
+	/**
+	 * @inheritDoc
+	 */
+	delete(value: T): void;
+	length(): number;
+}
+declare abstract class AbstractLinkedNode<T> {
+	protected _next: AbstractLinkedNode<T> | null;
+	protected readonly _data: T;
+	/**
+	 * Will create empty node
+	 */
+	protected constructor(data: T, next?: AbstractLinkedNode<T> | null);
+	/**
+	 * Get data of node
+	 */
+	get data(): T;
+	/**
+	 * Get next node link
+	 */
+	get next(): AbstractLinkedNode<T> | null;
+	/**
+	 * Set next node link
+	 */
+	set next(value: AbstractLinkedNode<T> | null);
+}
+declare abstract class AbstractLinkedList<T> implements ILinkedList<T> {
+	protected readonly _capacity: number;
+	protected _length: number;
+	protected _head: AbstractLinkedNode<T> | null;
+	protected _tail: AbstractLinkedNode<T> | null;
+	/**
+	 * Create empty instance
+	 */
+	protected constructor(capacity?: number);
+	/**
+	 * Will calculate real capacity value
+	 * @throws {ValueOutOfRangeException} when capacity is out of range
+	 */
+	private static calculateCapacity;
+	/**
+	 * Will insert node between nodeLeft and nodeRight
+	 * @throws {CollectionIsFullException} when list is full
+	 */
+	private insertNodeBetweenTwoNodes;
+	/**
+	 * Will remove the node from its neighbors nodes links
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	private deleteNode;
+	/**
+	 * Will find node by its index
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 * @throws {IndexOutOfBoundsException} when given index is out of range
+	 */
+	protected getNodeByIndex(index: number): AbstractLinkedNode<T>;
+	/**
+	 * Will set links between target, left and right siblings
+	 */
+	protected abstract insertNodeBetweenTwoNodesImpl(nodeToPush: AbstractLinkedNode<T>, nodeLeft: AbstractLinkedNode<T>, nodeRight: AbstractLinkedNode<T>): void;
+	/**
+	 * Will unset itself links and its neighbors links
+	 */
+	protected abstract deleteNodeImpl(node: AbstractLinkedNode<T>): void;
+	/**
+	 * Update head link
+	 */
+	protected abstract popImpl(): void;
+	/**
+	 * Update tail link
+	 */
+	protected abstract shiftImpl(): void;
+	/**
+	 * Will create empty node instance
+	 */
+	protected abstract createNode(value: T): AbstractLinkedNode<T>;
+	/**
+	 * Push into start
+	 * @throws {CollectionIsFullException} when there is no space available
+	 */
+	unshift(value: T): void;
+	/**
+	 * Push into end
+	 * @throws {CollectionIsFullException} when there is no space available
+	 */
+	push(value: T): void;
+	/**
+	 * Push from index
+	 * @throws {IndexOutOfBoundsException} when given index is out of range
+	 * @throws {CollectionIsFullException} when there is no space available
+	 */
+	pushFromIndex(value: T, fromIndex: number): void;
+	/**
+	 * Delete node from list's end
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	pop(): T;
+	/**
+	 * Delete node from list's start and get its data
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	shift(): T;
+	/**
+	 * Delete node from list by index from start
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 */
+	deleteFromIndex(fromIndex: number): T;
+	/**
+	 * List length
+	 */
+	length(): number;
+	/**
+	 * Is list empty
+	 */
+	isEmpty(): boolean;
+	/**
+	 * Is list full
+	 */
+	isFull(): boolean;
+	/**
+	 * Check if element exists in list
+	 */
+	has(item: T): boolean;
+	/**
+	 * Get head element data
+	 * @throws {CollectionIsEmptyException} when head does not exist
+	 */
+	peek(): T;
+	/**
+	 * Get tail element data
+	 * @throws {CollectionIsEmptyException} when tail does not exists
+	 */
+	peekFromStart(): T;
+	/**
+	 * Get list element by index from start
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 * @throws {IndexOutOfBoundsException} when given index is out of range
+	 */
+	peekByIndex(index: number): T;
+	/**
+	 * Remove all elements from list
+	 */
+	clear(): void;
+	/**
+	 * Get elements as an array
+	 */
+	getAsArray(): Array<T>;
+	/**
+	 * Add elements to list from array
+	 * @throws {CollectionIsFullException} when list is full
+	 * */
+	pushFromArray(elements: Array<T>): void;
+	/**
+	 * Reverse list nodes links and swap head with tail
+	 * @example "4>7>10" will be reversed to "10>7>4"
+	 */
+	abstract reverse(): void;
+}
+declare class DoubleLinkedNode<T> extends AbstractLinkedNode<T> {
+	protected _prev: DoubleLinkedNode<T> | null;
+	protected _next: DoubleLinkedNode<T> | null;
+	/**
+	 * Will create empty node
+	 */
+	constructor(data: T, next?: DoubleLinkedNode<T> | null, prev?: DoubleLinkedNode<T> | null);
+	/**
+	 * Set previous node link
+	 */
+	set prev(value: DoubleLinkedNode<T> | null);
+	/**
+	 * Get previous node link
+	 */
+	get prev(): DoubleLinkedNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	set next(value: DoubleLinkedNode<T> | null);
+	/**
+	 * @inheritDoc
+	 */
+	get next(): DoubleLinkedNode<T> | null;
+}
+/**
+ * Linear data structure
+ * Each node has next and prev sibling
+ * Head and tail are linked to each other
+ */
+export declare class DoubleLinkedList<T> extends AbstractLinkedList<T> {
+	/**
+	 * Override types
+	 */
+	protected _head: DoubleLinkedNode<T> | null;
+	protected _tail: DoubleLinkedNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(capacity?: number);
+	/**
+	 * @inheritDoc
+	 */
+	protected createNode(value: T): DoubleLinkedNode<T>;
+	/**
+	 * @inheritDoc
+	 */
+	protected insertNodeBetweenTwoNodesImpl(targetNode: DoubleLinkedNode<T>, leftNode: DoubleLinkedNode<T>, rightNode: DoubleLinkedNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected deleteNodeImpl(node: DoubleLinkedNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected popImpl(): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected shiftImpl(): void;
+	/**
+	 * @inheritDoc
+	 */
+	reverse(): void;
+}
+export interface IIterable<T> {
+	iterator(fromIndex?: number): IIterator<T>;
+}
+declare class SingleLinkedNode<T> extends AbstractLinkedNode<T> {
+	/**
+	 * @inheritDoc
+	 */
+	constructor(data: T, next?: SingleLinkedNode<T> | null);
+}
+/**
+ * Linear data structure
+ * Each node has next
+ * Head's next node is tail
+ */
+export declare class SingleLinkedList<T> extends AbstractLinkedList<T> {
+	/**
+	 * Override types
+	 */
+	protected _head: SingleLinkedNode<T> | null;
+	protected _tail: SingleLinkedNode<T> | null;
+	/**
+	 * @inheritDoc
+	 */
+	constructor(capacity?: number);
+	/**
+	 * Find previous sibling of given node
+	 */
+	private getPrevNode;
+	/**
+	 * @inheritDoc
+	 */
+	protected createNode(value: T): SingleLinkedNode<T>;
+	/**
+	 * @inheritDoc
+	 */
+	protected insertNodeBetweenTwoNodesImpl(targetNode: SingleLinkedNode<T>, leftNode: SingleLinkedNode<T>, rightNode: SingleLinkedNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected deleteNodeImpl(node: SingleLinkedNode<T>): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected popImpl(): void;
+	/**
+	 * @inheritDoc
+	 */
+	protected shiftImpl(): void;
+	/**
+	 * @inheritDoc
+	 */
+	reverse(): void;
+}
+/**
+ * @inheritDoc
+ */
+export declare class IterableSingleLinkedList<T> extends SingleLinkedList<T> implements IIterable<T> {
+	/**
+	 * @inheritDoc
+	 */
+	constructor(capacity?: number);
+	/**
+	 * List iterator
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 * @throws {IndexOutOfBoundsException} when given index is out of range
+	 */
+	iterator(fromIndex?: number): IIterator<T>;
+}
+export interface IBiDirectIterator<T> extends IIterator<T> {
+	/**
+	 * Will do one iteration back and returns prev item value
+	 */
+	prev(): T;
+	/**
+	 * Check if next element exists
+	 */
+	hasPrev(): boolean;
+}
+export interface IBiDirectIterable<T> extends IIterable<T> {
+	iterator(fromIndex?: number): IBiDirectIterator<T>;
+}
+/**
+ * @inheritDoc
+ */
+export declare class IterableDoubleLinkedList<T> extends DoubleLinkedList<T> implements IBiDirectIterable<T> {
+	/**
+	 * @inheritDoc
+	 */
+	constructor(capacity?: number);
+	/**
+	 * List iterator
+	 * @throws {CollectionIsEmptyException} when list is empty
+	 * @throws {IndexOutOfBoundsException} when given index is out of range
+	 */
+	iterator(fromIndex?: number): IBiDirectIterator<T>;
+}
+export declare class IllegalStateException extends Error {
+	constructor(message: string);
+}
+export declare class IsNotFoundException extends IllegalStateException {
+	constructor(message: string);
+}
+export declare class IsAlreadyExistsException extends IllegalStateException {
+	constructor(message: string);
+}
+export declare class IllegalArgumentException extends Error {
+	constructor(message: string);
+}
+export declare class ValueOutOfRangeException extends IllegalArgumentException {
+	constructor(message: string);
+}
+export declare class IndexOutOfBoundsException extends IllegalArgumentException {
+	constructor(message: string);
+}
+export declare class CollectionIsEmptyException extends IllegalStateException {
+	constructor(message: string);
+}
+export declare class CollectionIsFullException extends IllegalStateException {
+	constructor(message: string);
+}
+/**
+ * Bubble sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const bubbleSort: (arr: Array<number>) => Array<number>;
+/**
+ * Selection sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n \^ 2); Avg O(n \^ 2); Worst O(n \^ 2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const selectSort: (arr: Array<number>) => Array<number>;
+/**
+ * Merge sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n * log(n))
+ * @description
+ * Memory complexity: Worst case: O(n)
+ */
+export declare const mergeSort: (arr: Array<number>) => Array<number>;
+/**
+ * Insertion sorting algorithm
+ *
+ * @description
+ * Time complexity: Best O(n); Avg O(n \^ 2); Worst O(n \^ 2);
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const insertionSort: (arr: Array<number>) => Array<number>;
+/**
+ * Quick sort algorithm
+ *
+ * @description
+ * Time complexity: Best O(n * log(n)); Avg O(n * log(n)); Worst O(n  ^2)
+ * @description
+ * Memory complexity: Worst case: O(1)
+ */
+export declare const quickSort: (arr: Array<number>) => Array<number>;
+/**
+ * Wrapper function that storing the results of calls and returning the cached result when the same inputs occur again
+ */
+export declare const memoize: <Key, Value>(fn: FnToMemoize<Key, Value>) => FnToMemoize<Key, Value>;
+/**
+ * Will find min value in the whole array and return its index
+ */
+export declare const getMinIndex: (arr: Array<number>) => number;
+/**
+ * Will find min value in range between fromIndex and end of array
+ */
+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]
+ */
+export declare const swapArrayItems: <T>(arr: Array<T>, leftIndex: number, rightIndex: number) => void;
+/**
+ * Get random number in range
+ */
+export declare const randomizeNumberInRange: (min: number, max: number) => number;
+/**
+ * Round number to given digits after
+ */
+export declare const roundNumber: (num: number, digits?: number) => number;
+
+export {};