@raikuxq/alg-ds 1.1.6 → 1.2.1

package/lib/app/algorithms/sorts/merge-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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>;

package/lib/app/algorithms/sorts/merge-sort.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeSort = void 0;
+/**
+ * Merge two sorted arrays into one array
+ */
+var merge = function (arr, leftIndex, midIndex, rightIndex) {
+    var container = arr.slice(leftIndex, rightIndex + 1);
+    var resultArrIndex = leftIndex;
+    var leftHalfIndex = leftIndex;
+    var rightHalfIndex = midIndex + 1;
+    /** While both halves of array are not ended */
+    while (leftHalfIndex <= midIndex && rightHalfIndex <= rightIndex) {
+        var leftHalfElement = container[leftHalfIndex - leftIndex];
+        var 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
+ */
+var sortRange = function (arr, leftIndex, rightIndex) {
+    if (rightIndex > leftIndex) {
+        var 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)
+ */
+exports.mergeSort = function (arr) {
+    sortRange(arr, 0, arr.length - 1);
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/app/algorithms/sorts/quick-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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>;

package/lib/app/algorithms/sorts/quick-sort.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickSort = void 0;
+var utils_1 = require("../../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)
+ */
+exports.quickSort = function (arr) {
+    var partition = function (arr, leftIndex, rightIndex) {
+        var pivot = arr[leftIndex];
+        var leftWall = leftIndex;
+        var rightWall = rightIndex;
+        while (leftWall <= rightWall) {
+            while (arr[rightWall] > pivot) {
+                rightWall--;
+            }
+            while (arr[leftWall] < pivot) {
+                leftWall++;
+            }
+            if (leftWall <= rightWall) {
+                utils_1.swapArrayItems(arr, leftWall, rightWall);
+                rightWall--;
+                leftWall++;
+            }
+        }
+        return leftWall;
+    };
+    var sort = function (arr, leftIndex, rightIndex) {
+        if (leftIndex === void 0) { leftIndex = 0; }
+        if (rightIndex === void 0) { rightIndex = arr.length - 1; }
+        if (leftIndex < rightIndex) {
+            var pivot = partition(arr, leftIndex, rightIndex);
+            sort(arr, leftIndex, pivot - 1);
+            sort(arr, pivot, rightIndex);
+        }
+        return arr;
+    };
+    return sort(arr);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVpY2stc29ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9hcHAvYWxnb3JpdGhtcy9zb3J0cy9xdWljay1zb3J0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFDQUE2QztBQUU3Qzs7Ozs7OztHQU9HO0FBQ1UsUUFBQSxTQUFTLEdBQUcsVUFBQyxHQUFrQjtJQUMxQyxJQUFNLFNBQVMsR0FBRyxVQUNoQixHQUFrQixFQUNsQixTQUFpQixFQUNqQixVQUFrQjtRQUVsQixJQUFNLEtBQUssR0FBRyxHQUFHLENBQUMsU0FBUyxDQUFDLENBQUM7UUFFN0IsSUFBSSxRQUFRLEdBQUcsU0FBUyxDQUFDO1FBQ3pCLElBQUksU0FBUyxHQUFHLFVBQVUsQ0FBQztRQUUzQixPQUFPLFFBQVEsSUFBSSxTQUFTLEVBQUU7WUFDNUIsT0FBTyxHQUFHLENBQUMsU0FBUyxDQUFDLEdBQUcsS0FBSyxFQUFFO2dCQUM3QixTQUFTLEVBQUUsQ0FBQzthQUNiO1lBQ0QsT0FBTyxHQUFHLENBQUMsUUFBUSxDQUFDLEdBQUcsS0FBSyxFQUFFO2dCQUM1QixRQUFRLEVBQUUsQ0FBQzthQUNaO1lBQ0QsSUFBSSxRQUFRLElBQUksU0FBUyxFQUFFO2dCQUN6QixzQkFBYyxDQUFDLEdBQUcsRUFBRSxRQUFRLEVBQUUsU0FBUyxDQUFDLENBQUM7Z0JBQ3pDLFNBQVMsRUFBRSxDQUFDO2dCQUNaLFFBQVEsRUFBRSxDQUFDO2FBQ1o7U0FDRjtRQUVELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUMsQ0FBQztJQUVGLElBQU0sSUFBSSxHQUFHLFVBQ1gsR0FBa0IsRUFDbEIsU0FBYSxFQUNiLFVBQW1DO1FBRG5DLDBCQUFBLEVBQUEsYUFBYTtRQUNiLDJCQUFBLEVBQUEsYUFBcUIsR0FBRyxDQUFDLE1BQU0sR0FBRyxDQUFDO1FBRW5DLElBQUksU0FBUyxHQUFHLFVBQVUsRUFBRTtZQUMxQixJQUFNLEtBQUssR0FBRyxTQUFTLENBQUMsR0FBRyxFQUFFLFNBQVMsRUFBRSxVQUFVLENBQUMsQ0FBQztZQUVwRCxJQUFJLENBQUMsR0FBRyxFQUFFLFNBQVMsRUFBRSxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUM7WUFDaEMsSUFBSSxDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsVUFBVSxDQUFDLENBQUM7U0FDOUI7UUFDRCxPQUFPLEdBQUcsQ0FBQztJQUNiLENBQUMsQ0FBQztJQUVGLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ25CLENBQUMsQ0FBQyJ9

package/lib/app/algorithms/sorts/select-sort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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>;

package/lib/app/algorithms/sorts/select-sort.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSort = void 0;
+var utils_1 = require("../../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)
+ */
+exports.selectSort = function (arr) {
+    for (var index = 0; index < arr.length; index++) {
+        var minIndex = utils_1.getMinIndexFromIndex(arr, index);
+        utils_1.swapArrayItems(arr, minIndex, index);
+    }
+    return arr;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LXNvcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBwL2FsZ29yaXRobXMvc29ydHMvc2VsZWN0LXNvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEscUNBQW1FO0FBRW5FOzs7Ozs7O0dBT0c7QUFDVSxRQUFBLFVBQVUsR0FBRyxVQUFDLEdBQWtCO0lBQzNDLEtBQUssSUFBSSxLQUFLLEdBQUcsQ0FBQyxFQUFFLEtBQUssR0FBRyxHQUFHLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxFQUFFO1FBQy9DLElBQU0sUUFBUSxHQUFXLDRCQUFvQixDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUUxRCxzQkFBYyxDQUFTLEdBQUcsRUFBRSxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUM7S0FDOUM7SUFFRCxPQUFPLEdBQUcsQ0FBQztBQUNiLENBQUMsQ0FBQyJ9

package/lib/app/algorithms/transpose-matrix.d.ts

@@ -0,0 +1,5 @@
+import { TypeArrayMatrix } from "../types/TypeArrayMatrix";
+/**
+ * Will flips a matrix over its diagonal
+ */
+export declare const transposeMatrix: (matrix: TypeArrayMatrix) => TypeArrayMatrix;

package/lib/app/algorithms/transpose-matrix.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transposeMatrix = void 0;
+var IllegalArgumentException_1 = require("../exceptions/base/IllegalArgumentException");
+var utils_1 = require("../utils");
+/**
+ * Will flips a matrix over its diagonal
+ */
+exports.transposeMatrix = function (matrix) {
+    if (!utils_1.checkIsArrayMatrix(matrix)) {
+        throw new IllegalArgumentException_1.default("Given array is not a matrix");
+    }
+    return matrix.reduce(function (acc, current, currentIndex) {
+        acc[currentIndex] = matrix.map(function (rowArr) { return rowArr[currentIndex]; });
+        return acc;
+    }, new Array(matrix.length));
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3NlLW1hdHJpeC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvYWxnb3JpdGhtcy90cmFuc3Bvc2UtbWF0cml4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHdGQUFtRjtBQUNuRixrQ0FBOEM7QUFFOUM7O0dBRUc7QUFDVSxRQUFBLGVBQWUsR0FBRyxVQUFDLE1BQXVCO0lBQ3JELElBQUksQ0FBQywwQkFBa0IsQ0FBQyxNQUFNLENBQUMsRUFBRTtRQUMvQixNQUFNLElBQUksa0NBQXdCLENBQUMsNkJBQTZCLENBQUMsQ0FBQztLQUNuRTtJQUVELE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxVQUFDLEdBQUcsRUFBRSxPQUFPLEVBQUUsWUFBWTtRQUM5QyxHQUFHLENBQUMsWUFBWSxDQUFDLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxVQUFDLE1BQU0sSUFBSyxPQUFBLE1BQU0sQ0FBQyxZQUFZLENBQUMsRUFBcEIsQ0FBb0IsQ0FBQyxDQUFDO1FBQ2pFLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQyxFQUFFLElBQUksS0FBSyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDO0FBQy9CLENBQUMsQ0FBQyJ9

package/lib/app/constants.d.ts

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

package/lib/app/constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDGE_NOT_EXISTS_STATE = exports.EDGE_EXISTS_STATE = void 0;
+exports.EDGE_EXISTS_STATE = 1;
+exports.EDGE_NOT_EXISTS_STATE = 0;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcC9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQWEsUUFBQSxpQkFBaUIsR0FBRyxDQUFDLENBQUM7QUFDdEIsUUFBQSxxQkFBcUIsR0FBRyxDQUFDLENBQUMifQ==

package/lib/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.d.ts

@@ -0,0 +1,15 @@
+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);
+    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);
+}

package/lib/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryNode.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var AbstractBinaryNode = /** @class */ (function () {
+    function AbstractBinaryNode(initialData) {
+        this._data = initialData;
+        this._left = null;
+        this._right = null;
+        this._parent = null;
+    }
+    Object.defineProperty(AbstractBinaryNode.prototype, "data", {
+        get: function () {
+            return this._data;
+        },
+        set: function (value) {
+            this._data = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (value) {
+            this._left = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (value) {
+            this._right = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AbstractBinaryNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (value) {
+            this._parent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return AbstractBinaryNode;
+}());
+exports.default = AbstractBinaryNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RCaW5hcnlOb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvQmluYXJ5VHJlZS9BYnN0cmFjdEJpbmFyeVRyZWUvQWJzdHJhY3RCaW5hcnlOb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUE7SUFNRSw0QkFBc0IsV0FBYztRQUNsQyxJQUFJLENBQUMsS0FBSyxHQUFHLFdBQVcsQ0FBQztRQUN6QixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztRQUNuQixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztJQUN0QixDQUFDO0lBRUQsc0JBQVcsb0NBQUk7YUFBZjtZQUNFLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQztRQUNwQixDQUFDO2FBRUQsVUFBZ0IsS0FBUTtZQUN0QixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNyQixDQUFDOzs7T0FKQTtJQU1ELHNCQUFXLG9DQUFJO2FBQWY7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQzthQUVELFVBQWdCLEtBQW1DO1lBQ2pELElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcscUNBQUs7YUFBaEI7WUFDRSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDckIsQ0FBQzthQUVELFVBQWlCLEtBQW1DO1lBQ2xELElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO1FBQ3RCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsc0NBQU07YUFBakI7WUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQzthQUVELFVBQWtCLEtBQW1DO1lBQ25ELElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ3ZCLENBQUM7OztPQUpBO0lBS0gseUJBQUM7QUFBRCxDQUFDLEFBNUNELElBNENDIn0=

package/lib/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.d.ts

@@ -0,0 +1,60 @@
+import IBinaryTree from "../../../types/IBinaryTree";
+import { FnCompareTwo } from "../../../types/FnCompareTwo";
+import AbstractBinaryNode from "./AbstractBinaryNode";
+import { EnumTreeTraversalType } from "../../../types/EnumTreeTraversalType";
+/**
+ *
+ */
+export default 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>;
+}

package/lib/app/data-structures/BinaryTree/AbstractBinaryTree/AbstractBinaryTree.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ *
+ */
+var AbstractBinaryTree = /** @class */ (function () {
+    /**
+     *
+     * @param fnCompare
+     * @protected
+     */
+    function AbstractBinaryTree(fnCompare) {
+        /**
+         * Function that checks is node A better
+         * @default a > b
+         * @example 5 > 4
+         * @example 'abc' > 'aba'
+         */
+        this.compare = function (a, b) { return a > b; };
+        if (fnCompare) {
+            this.compare = fnCompare;
+            console.log(this.compare);
+        }
+        this._head = null;
+        this._length = 0;
+    }
+    /**
+     * Returns nodes count in the entire tree
+     */
+    AbstractBinaryTree.prototype.length = function () {
+        return this._length;
+    };
+    return AbstractBinaryTree;
+}());
+exports.default = AbstractBinaryTree;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJzdHJhY3RCaW5hcnlUcmVlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9kYXRhLXN0cnVjdHVyZXMvQmluYXJ5VHJlZS9BYnN0cmFjdEJpbmFyeVRyZWUvQWJzdHJhY3RCaW5hcnlUcmVlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBS0E7O0dBRUc7QUFDSDtJQVdFOzs7O09BSUc7SUFDSCw0QkFBc0IsU0FBMkI7UUFmakQ7Ozs7O1dBS0c7UUFDTyxZQUFPLEdBQW9CLFVBQUMsQ0FBSSxFQUFFLENBQUksSUFBSyxPQUFBLENBQUMsR0FBRyxDQUFDLEVBQUwsQ0FBSyxDQUFDO1FBVXpELElBQUksU0FBUyxFQUFFO1lBQ2IsSUFBSSxDQUFDLE9BQU8sR0FBRyxTQUFTLENBQUM7WUFDekIsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDM0I7UUFDRCxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixJQUFJLENBQUMsT0FBTyxHQUFHLENBQUMsQ0FBQztJQUNuQixDQUFDO0lBRUQ7O09BRUc7SUFDSSxtQ0FBTSxHQUFiO1FBQ0UsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDO0lBQ3RCLENBQUM7SUF5Q0gseUJBQUM7QUFBRCxDQUFDLEFBdkVELElBdUVDIn0=

package/lib/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.d.ts

@@ -0,0 +1,13 @@
+import AbstractBinaryNode from "../AbstractBinaryTree/AbstractBinaryNode";
+export default 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);
+}

package/lib/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.js

@@ -0,0 +1,59 @@
+"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 AbstractBinaryNode_1 = require("../AbstractBinaryTree/AbstractBinaryNode");
+var BinarySearchNode = /** @class */ (function (_super) {
+    __extends(BinarySearchNode, _super);
+    function BinarySearchNode(initialData) {
+        var _this = _super.call(this, initialData) || this;
+        _this._left = null;
+        _this._right = null;
+        _this._parent = null;
+        return _this;
+    }
+    Object.defineProperty(BinarySearchNode.prototype, "left", {
+        get: function () {
+            return this._left;
+        },
+        set: function (value) {
+            this._left = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchNode.prototype, "right", {
+        get: function () {
+            return this._right;
+        },
+        set: function (value) {
+            this._right = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BinarySearchNode.prototype, "parent", {
+        get: function () {
+            return this._parent;
+        },
+        set: function (value) {
+            this._parent = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BinarySearchNode;
+}(AbstractBinaryNode_1.default));
+exports.default = BinarySearchNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQmluYXJ5U2VhcmNoTm9kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvZGF0YS1zdHJ1Y3R1cmVzL0JpbmFyeVRyZWUvQmluYXJ5U2VhcmNoVHJlZS9CaW5hcnlTZWFyY2hOb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtFQUEwRTtBQUUxRTtJQUFpRCxvQ0FBcUI7SUFLcEUsMEJBQW1CLFdBQWM7UUFBakMsWUFDRSxrQkFBTSxXQUFXLENBQUMsU0FJbkI7UUFIQyxLQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztRQUNsQixLQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQztRQUNuQixLQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQzs7SUFDdEIsQ0FBQztJQUVELHNCQUFXLGtDQUFJO2FBQWY7WUFDRSxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7UUFDcEIsQ0FBQzthQUVELFVBQWdCLEtBQWlDO1lBQy9DLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsbUNBQUs7YUFBaEI7WUFDRSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDckIsQ0FBQzthQUVELFVBQWlCLEtBQWlDO1lBQ2hELElBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSyxDQUFDO1FBQ3RCLENBQUM7OztPQUpBO0lBTUQsc0JBQVcsb0NBQU07YUFBakI7WUFDRSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7UUFDdEIsQ0FBQzthQUVELFVBQWtCLEtBQWlDO1lBQ2pELElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ3ZCLENBQUM7OztPQUpBO0lBS0gsdUJBQUM7QUFBRCxDQUFDLEFBbkNELENBQWlELDRCQUFrQixHQW1DbEUifQ==

package/lib/app/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.d.ts

@@ -0,0 +1,70 @@
+import { FnCompareTwo } from "../../../types/FnCompareTwo";
+import { EnumTreeTraversalType } from "../../../types/EnumTreeTraversalType";
+import IBinaryTree from "../../../types/IBinaryTree";
+import AbstractBinaryTree from "../AbstractBinaryTree/AbstractBinaryTree";
+import BinarySearchNode from "./BinarySearchNode";
+/**
+ * Unbalanced binary search tree implementation
+ */
+export default class BinarySearchTree<T> extends AbstractBinaryTree<T> {
+    /**
+     * Override types
+     */
+    protected _head: BinarySearchNode<T> | null;
+    /**
+     * @inheritDoc
+     */
+    constructor(fnCompare?: FnCompareTwo<T>);
+    /**
+     *
+     * @throws when head 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
+     */
+    max(): T;
+    /**
+     * @inheritDoc
+     */
+    min(): T;
+    /**
+     * @inheritDoc
+     */
+    insert(value: T): void;
+    /**
+     * @inheritDoc
+     */
+    has(value: T): boolean;
+    /**
+     * @inheritDoc
+     */
+    delete(value: T): void;
+    /**
+     * @inheritDoc
+     */
+    subtree(value: T): IBinaryTree<T>;
+    /**
+     * @inheritDoc
+     */
+    traverse(type: EnumTreeTraversalType, from?: T): Array<T>;
+    /**
+     * Calc max height of the largest branch of the tree
+     */
+    height(): number;
+}