@raikuxq/alg-ds 1.0.0

package/.eslintrc.js

@@ -0,0 +1,14 @@
+module.exports = {
+  root: true,
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint", "prettier"],
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended",
+    "prettier/@typescript-eslint",
+  ],
+  env: {
+    node: true,
+  },
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Alexey Stepanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,221 @@
+Common algorithms and data structures.
+
+Written in TypeScript, tested with Jest.
+
+# Getting started
+
+Clone this repository and install dependencies by using `yarn` command.
+
++ `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)
+  + [Sorting algorithms](#sorting-algorithms)
++ [Iterators](#iterators)
++ [Linear data structures](#linear-data-structures)
+  + [Linked list](#linked-list)
+  + [Looped array](#looped-array)
+  + [Stack](#stack)
+  + [Queue](#queue)
++ [Non-linear data structures](#non-linear-data-structures)
+  + [Graph](#graph)
+  + [Binary tree](#binary-trees)
+
+
+# Algorithms
+
+## Uncategorized algorithms
+[memoize](src/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)).
+
+[factorial](src/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.
+
+[transpose-matrix](src/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.
+
+[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. 
+
+[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. 
+
+[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. 
+
+[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. 
+
+
+
+
+# Iterators
+
+### Interfaces
+[IIterable](src/types/IIterable.ts) — Allows to create an iterator instance.
+
+[IBiDirectIterable](src/types/IBiDirectIterable.ts) — Allows to create a bi-direct iterator instance. 
+Extends [IIterable](src/types/IIterable.ts) interface.
+
+[IIterator](src/types/IIterator.ts) — Allows only next navigation.
+
+[IBiDirectIterator](src/types/IBiDirectIterator.ts) — Allows both next and prev navigation. 
+Extends [IIterator](src/types/IIterator.ts) interface.
+
+
+# Linear data structures
+
+### Interfaces
+[ILinearStorage](src/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.
+
+[IConvertableToArray](src/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.
+
+### 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.
+
+[SingleLinkedList](src/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.
+
+[DoubleLinkedList](src/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.
+
+
+## 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.
+
+### Implementation
+[LoopedArray](src/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.
+
+## 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.
+  
+
+
+# Non linear data structures
+
+## Graph
+### Interfaces
+[IGraph](src/types/IGraph.ts) — Contains basic graph operations.
+
+[IGraphIterator](src/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.
+
+### Implementation
+[GraphEdge](src/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.
+
+
+[DirectedGraph](src/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) 
+— In case of undirected graph A->B and B->A are equal.
+
+
+### Graph Iterators
+
+[BreadthFirstSearchIterator](src/data-structures/Graph/iterator/GraphIteratorBFS.ts) 
+— Traversal method for unweighted graphs, built on queue.
+
+[DepthFirstSearchIterator](src/data-structures/Graph/iterator/GraphIteratorDFS.ts)
+— Traversal method for unweighted graphs, built on stack.
+
+[DijkstraMethodIterator](src/data-structures/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)] 
+— 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)]
+— 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)] 
+— 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)] 
+— 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)] 
+— 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 a directed graph (undirected graphs are symmetrical already).
+
+
+
+## Binary trees
+[IBinaryTree](src/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.
+
+[AbstractBinaryTree](src/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.
+
+[BinarySearchTree](src/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).
+
+
+
+[RandBinarySearchNode](src/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.ts) — Have a rank attribute. 
+Extends [BinarySearchNode](src/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts).
+
+[RandBinarySearchTree](src/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).

package/jest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+};

package/nodemon.json

@@ -0,0 +1,6 @@
+{
+  "watch": ["src"],
+  "ext": ".ts,.js",
+  "ignore": [],
+  "exec": "ts-node ./src/index.ts"
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@raikuxq/alg-ds",
+  "scripts": {
+    "test": "jest",
+    "dev": "nodemon",
+    "build": "rimraf ./build && tsc",
+    "start": "npm run build && node build/main.js",
+    "lint": "yarn eslint . --ext .ts",
+    "lint:fix": "yarn eslint --fix .  --ext .ts"
+  },
+  "exports": {
+    ".": "./src/exports/main.ts",
+    "algorithms": "./src/exports/algorithms.ts",
+    "sorts": "./src/exports/algorithms/sorts.ts",
+    "types": "./src/exports/types.ts",
+    "utils": "./src/exports/utils.ts",
+    "constants": "./src/exports/constants.ts",
+    "helpers": "./src/exports/helpers.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/raikuxq/lab-ts-algorithms"
+  },
+  "devDependencies": {
+    "@types/jest": "^26.0.14",
+    "@types/node": "^14.0.24",
+    "@typescript-eslint/eslint-plugin": "^4.4.0",
+    "@typescript-eslint/parser": "^4.4.0",
+    "eslint": "^7.11.0",
+    "eslint-config-prettier": "^6.12.0",
+    "eslint-config-recommended": "^4.1.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "jest": "^26.1.0",
+    "nodemon": "^2.0.4",
+    "prettier": "^2.1.2",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^26.4.1",
+    "ts-node": "^8.10.2",
+    "typescript": "^4.0.3"
+  },
+  "dependencies": {},
+  "version": "1.0.0"
+}

package/src/algorithms/binary-search.ts

@@ -0,0 +1,28 @@
+/**
+ * Find element's index in sorted array
+ * Time complexity: O(log(n))
+ */
+export const binarySearch = (
+  elements: Array<number>,
+  searchElement: number
+): number | null => {
+  const length: number = elements.length;
+
+  let leftIndex = 0;
+  let rightIndex: number = length - 1;
+
+  while (leftIndex <= rightIndex) {
+    const midIndex: number = Math.ceil((leftIndex + rightIndex) / 2);
+    const midEl: number = elements[midIndex];
+
+    if (searchElement == midEl) {
+      return midIndex;
+    } else if (midEl > searchElement) {
+      rightIndex = midIndex - 1;
+    } else if (midEl < searchElement) {
+      leftIndex = midIndex + 1;
+    }
+  }
+
+  return null;
+};

package/src/algorithms/factorial.ts

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

package/src/algorithms/fibonacci.ts

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

package/src/algorithms/memoize.ts

@@ -0,0 +1,21 @@
+import { FnToMemoize } from "../types/FnToMemoize";
+
+/**
+ * Wrapper function that storing the results of calls and returning the cached result when the same inputs occur again
+ */
+export const memoize = <Key, Value>(
+  fn: FnToMemoize<Key, Value>
+): FnToMemoize<Key, Value> => {
+  const cache = new Map<string, Value>();
+
+  return (...args: Array<Key>): Value => {
+    const jsonArgs = JSON.stringify(args);
+
+    if (!cache.has(jsonArgs)) {
+      const result = fn(...args);
+      cache.set(jsonArgs, result);
+    }
+
+    return <Value>cache.get(jsonArgs);
+  };
+};

package/src/algorithms/sorts/bubble-sort.ts

@@ -0,0 +1,21 @@
+import { swapArrayItems } from "../../utils";
+
+/**
+ * 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 const bubbleSort = (arr: Array<number>): Array<number> => {
+  for (let i = 0; i < arr.length - 1; i++) {
+    for (let j = 0; j < arr.length - 1; j++) {
+      if (arr[j] > arr[j + 1]) {
+        swapArrayItems(arr, j, j + 1);
+      }
+    }
+  }
+
+  return arr;
+};

package/src/algorithms/sorts/insertion-sort.ts

@@ -0,0 +1,25 @@
+import { swapArrayItems } from "../../utils";
+
+/**
+ * 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 const insertionSort = (arr: Array<number>): Array<number> => {
+  for (let i = 1; i < arr.length; i++) {
+    const current = arr[i];
+    let j = i - 1;
+
+    while (j >= 0 && arr[j] > current) {
+      swapArrayItems(arr, j + 1, j);
+      j--;
+    }
+
+    arr[j + 1] = current;
+  }
+
+  return arr;
+};

package/src/algorithms/sorts/merge-sort.ts

@@ -0,0 +1,74 @@
+/**
+ * Merge two sorted arrays into one array
+ */
+const merge = (
+  arr: Array<number>,
+  leftIndex: number,
+  midIndex: number,
+  rightIndex: number
+) => {
+  const container = arr.slice(leftIndex, rightIndex + 1);
+
+  let resultArrIndex = leftIndex;
+  let leftHalfIndex = leftIndex;
+  let rightHalfIndex = midIndex + 1;
+
+  /** While both halves of array are not ended */
+  while (leftHalfIndex <= midIndex && rightHalfIndex <= rightIndex) {
+    const leftHalfElement = container[leftHalfIndex - leftIndex];
+    const rightHalfElement = container[rightHalfIndex - leftIndex];
+
+    if (leftHalfElement < rightHalfElement) {
+      arr[resultArrIndex] = leftHalfElement;
+      leftHalfIndex++;
+    } else {
+      arr[resultArrIndex] = rightHalfElement;
+      rightHalfIndex++;
+    }
+    resultArrIndex++;
+  }
+
+  /** If one of halves is ended, the remaining one will just be pushed to result */
+  while (leftHalfIndex <= midIndex) {
+    arr[resultArrIndex] = container[leftHalfIndex - leftIndex];
+    resultArrIndex++;
+    leftHalfIndex++;
+  }
+  while (rightHalfIndex <= rightIndex) {
+    arr[resultArrIndex] = container[rightHalfIndex - leftIndex];
+    resultArrIndex++;
+    rightHalfIndex++;
+  }
+};
+
+/**
+ * Divide array into 2 halves and merge them
+ */
+const sortRange = (
+  arr: Array<number>,
+  leftIndex: number,
+  rightIndex: number
+) => {
+  if (rightIndex > leftIndex) {
+    const midIndex = Math.floor(leftIndex + (rightIndex - leftIndex) / 2);
+
+    sortRange(arr, leftIndex, midIndex);
+    sortRange(arr, midIndex + 1, rightIndex);
+
+    merge(arr, leftIndex, midIndex, rightIndex);
+  }
+};
+
+/**
+ * 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 const mergeSort = (arr: Array<number>): Array<number> => {
+  sortRange(arr, 0, arr.length - 1);
+
+  return arr;
+};

package/src/algorithms/sorts/quick-sort.ts

@@ -0,0 +1,54 @@
+import { swapArrayItems } from "../../utils";
+
+/**
+ * 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 const quickSort = (arr: Array<number>): Array<number> => {
+  const partition = (
+    arr: Array<number>,
+    leftIndex: number,
+    rightIndex: number
+  ): number => {
+    const pivot = arr[leftIndex];
+
+    let leftWall = leftIndex;
+    let rightWall = rightIndex;
+
+    while (leftWall <= rightWall) {
+      while (arr[rightWall] > pivot) {
+        rightWall--;
+      }
+      while (arr[leftWall] < pivot) {
+        leftWall++;
+      }
+      if (leftWall <= rightWall) {
+        swapArrayItems(arr, leftWall, rightWall);
+        rightWall--;
+        leftWall++;
+      }
+    }
+
+    return leftWall;
+  };
+
+  const sort = (
+    arr: Array<number>,
+    leftIndex = 0,
+    rightIndex: number = arr.length - 1
+  ): Array<number> => {
+    if (leftIndex < rightIndex) {
+      const pivot = partition(arr, leftIndex, rightIndex);
+
+      sort(arr, leftIndex, pivot - 1);
+      sort(arr, pivot, rightIndex);
+    }
+    return arr;
+  };
+
+  return sort(arr);
+};

package/src/algorithms/sorts/select-sort.ts

@@ -0,0 +1,19 @@
+import { swapArrayItems, getMinIndexFromIndex } from "../../utils";
+
+/**
+ * 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 const selectSort = (arr: Array<number>): Array<number> => {
+  for (let index = 0; index < arr.length; index++) {
+    const minIndex: number = getMinIndexFromIndex(arr, index);
+
+    swapArrayItems<number>(arr, minIndex, index);
+  }
+
+  return arr;
+};

package/src/algorithms/transpose-matrix.ts

@@ -0,0 +1,19 @@
+import { ArrayMatrix } from "../types/ArrayMatrix";
+
+/**
+ * Will flips a matrix over its diagonal
+ */
+export const transposeMatrix = (matrix: ArrayMatrix): ArrayMatrix => {
+  /** Validation */
+  matrix.forEach((subArray) => {
+    const checkIsSameLength = subArray.length === matrix.length;
+    if (!checkIsSameLength) {
+      throw new Error("Given array is not a matrix");
+    }
+  });
+
+  return matrix.reduce((acc, current, currentIndex) => {
+    acc[currentIndex] = matrix.map((rowArr) => rowArr[currentIndex]);
+    return acc;
+  }, new Array(matrix.length));
+};

package/src/constants.ts

@@ -0,0 +1,2 @@
+export const EDGE_EXISTS_STATE = 1;
+export const EDGE_NOT_EXISTS_STATE = 0;

package/src/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.ts

@@ -0,0 +1,45 @@
+export default 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) {
+    this._data = initialData;
+    this._left = null;
+    this._right = null;
+    this._parent = null;
+  }
+
+  public get data(): T {
+    return this._data;
+  }
+
+  public set data(value: T) {
+    this._data = value;
+  }
+
+  public get left(): AbstractBinaryNode<T> | null {
+    return this._left;
+  }
+
+  public set left(value: AbstractBinaryNode<T> | null) {
+    this._left = value;
+  }
+
+  public get right(): AbstractBinaryNode<T> | null {
+    return this._right;
+  }
+
+  public set right(value: AbstractBinaryNode<T> | null) {
+    this._right = value;
+  }
+
+  public get parent(): AbstractBinaryNode<T> | null {
+    return this._parent;
+  }
+
+  public set parent(value: AbstractBinaryNode<T> | null) {
+    this._parent = value;
+  }
+}