@raikuxq/alg-ds 1.1.2 → 1.1.5

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

@@ -1,80 +0,0 @@
-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> = (a: T, b: T) => a > b;
-  protected _head: AbstractBinaryNode<T> | null;
-  protected _length: number;
-
-  /**
-   *
-   * @param fnCompare
-   * @protected
-   */
-  protected constructor(fnCompare?: FnCompareTwo<T>) {
-    if (fnCompare) {
-      this.compare = fnCompare;
-      console.log(this.compare);
-    }
-    this._head = null;
-    this._length = 0;
-  }
-
-  /**
-   * Returns nodes count in the entire tree
-   */
-  public length(): number {
-    return this._length;
-  }
-
-  /**
-   * Will create new node and place it according to the type of tree rules
-   */
-  public abstract insert(value: T): void;
-
-  /**
-   * Will check if tree has a node with given data
-   */
-  public abstract has(value: T): boolean;
-
-  /**
-   * Will delete node from the tree and restructure it
-   */
-  public abstract delete(value: T): void;
-
-  /**
-   * Max value of the tree
-   */
-  public abstract max(): T;
-
-  /**
-   * Min value of the tree
-   */
-  public abstract min(): T;
-
-  /**
-   * Returns same class instance with new head node
-   */
-  public abstract subtree(value: T): IBinaryTree<T>;
-
-  /**
-   * Returns the highest branch length in the tree
-   */
-  public abstract height(): number;
-
-  /**
-   * In-order/Pre-order/Post-order traversing of the tree
-   */
-  public abstract traverse(type: EnumTreeTraversalType): Array<T>;
-}

package/src/data-structures/BinaryTree/BinarySearchTree/BinarySearchNode.ts

@@ -1,38 +0,0 @@
-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;
-
-  public constructor(initialData: T) {
-    super(initialData);
-    this._left = null;
-    this._right = null;
-    this._parent = null;
-  }
-
-  public get left(): BinarySearchNode<T> | null {
-    return this._left;
-  }
-
-  public set left(value: BinarySearchNode<T> | null) {
-    this._left = value;
-  }
-
-  public get right(): BinarySearchNode<T> | null {
-    return this._right;
-  }
-
-  public set right(value: BinarySearchNode<T> | null) {
-    this._right = value;
-  }
-
-  public get parent(): BinarySearchNode<T> | null {
-    return this._parent;
-  }
-
-  public set parent(value: BinarySearchNode<T> | null) {
-    this._parent = value;
-  }
-}

package/src/data-structures/BinaryTree/BinarySearchTree/BinarySearchTree.ts

@@ -1,286 +0,0 @@
-import { FnCompareTwo } from "../../../types/FnCompareTwo";
-import { EnumTreeTraversalType } from "../../../types/EnumTreeTraversalType";
-import IBinaryTree from "../../../types/IBinaryTree";
-import AbstractBinaryTree from "../AbstractBinaryTree/AbstractBinaryTree";
-import BinarySearchNode from "./BinarySearchNode";
-import Queue from "../../Queue/Queue";
-
-/**
- * Unbalanced binary search tree implementation
- */
-export default class BinarySearchTree<T> extends AbstractBinaryTree<T> {
-  /**
-   * Override types
-   */
-  protected _head: BinarySearchNode<T> | null;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(fnCompare?: FnCompareTwo<T>) {
-    super(fnCompare);
-    this._head = null;
-  }
-
-  /**
-   *
-   * @throws when head is empty
-   */
-  protected checkIsEmpty(): void {
-    if (this._head === null) {
-      throw new Error("Tree is empty");
-    }
-  }
-
-  /**
-   * Will update left and right links parent with current node
-   */
-  protected updateLeftRightParents(node: BinarySearchNode<T>): void {
-    if (node.left && node.left.parent !== node) {
-      node.left.parent = node;
-    }
-    if (node.right && node.right.parent !== node) {
-      node.right.parent = node;
-    }
-  }
-
-  /**
-   * Will return node instance by its data
-   */
-  protected findNode(value: T): BinarySearchNode<T> | null {
-    let current = this._head;
-
-    while (current && current.data !== value) {
-      current = this.compare(current.data, value)
-        ? current.left
-        : current.right;
-    }
-
-    return current;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected insertToLeaf(createdNode: BinarySearchNode<T>): void {
-    let parent = null;
-    let current = this._head;
-
-    while (current) {
-      parent = current;
-
-      current = this.compare(current.data, createdNode.data)
-        ? current.left
-        : current.right;
-    }
-
-    createdNode.parent = parent;
-
-    if (parent === null) {
-      this._head = createdNode;
-    } else {
-      if (this.compare(parent.data, createdNode.data)) {
-        parent.left = createdNode;
-      } else {
-        parent.right = createdNode;
-      }
-    }
-    this._length++;
-  }
-
-  /**
-   * Will join two trees into one   */
-  protected join(
-    treeLeft: BinarySearchNode<T> | null,
-    treeRight: BinarySearchNode<T> | null
-  ): BinarySearchNode<T> | null {
-    if (treeLeft === null) {
-      return treeRight;
-    }
-    if (treeRight === null) {
-      return treeLeft;
-    }
-
-    treeRight.left = this.join(treeLeft, treeRight.left);
-    if (treeRight.left) {
-      this.updateLeftRightParents(treeRight);
-    }
-    return treeRight;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public max(): T {
-    this.checkIsEmpty();
-    let currentNode = this._head;
-    while (currentNode?.right) {
-      currentNode = currentNode.right;
-    }
-    return currentNode!.data;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public min(): T {
-    this.checkIsEmpty();
-    let currentNode = this._head;
-    while (currentNode?.left) {
-      currentNode = currentNode.left;
-    }
-    return currentNode!.data;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public insert(value: T): void {
-    if (this.has(value)) {
-      throw new Error("Node already exists");
-    }
-    const createdNode = new BinarySearchNode(value);
-    this.insertToLeaf(createdNode);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public has(value: T): boolean {
-    const current = this.findNode(value);
-    return current?.data === value;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public delete(value: T): void {
-    if (!this.has(value)) {
-      throw new Error("Value does not exist in the tree");
-    }
-
-    const recursiveDelete = (node: BinarySearchNode<T> | null, value: T) => {
-      if (node === null) {
-        return node;
-      }
-
-      if (node.data === value) {
-        const updatedNode = this.join(node.left, node.right);
-        if (updatedNode) {
-          updatedNode.parent = node.parent;
-        }
-        return updatedNode;
-      } else if (this.compare(node.data, value)) {
-        node.left = recursiveDelete(node.left, value);
-      } else {
-        node.right = recursiveDelete(node.right, value);
-      }
-      this.updateLeftRightParents(node);
-      return node;
-    };
-
-    this._head = recursiveDelete(this._head, value);
-    this._length--;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public subtree(value: T): IBinaryTree<T> {
-    const tree = new BinarySearchTree<T>();
-    const node = this.findNode(value);
-    const queue = new Queue<BinarySearchNode<T> | null>();
-
-    const traverse = [];
-    queue.push(node);
-
-    while (!queue.isEmpty()) {
-      const currentNode = queue.pop();
-      traverse.push(currentNode);
-      if (currentNode?.left) {
-        queue.push(currentNode.left);
-      }
-      if (currentNode?.right) {
-        queue.push(currentNode.right);
-      }
-    }
-
-    traverse.forEach((elem) => {
-      if (elem !== null) {
-        tree.insert(elem.data);
-      }
-    });
-
-    return tree;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public traverse(type: EnumTreeTraversalType, from?: T): Array<T> {
-    this.checkIsEmpty();
-
-    const array = new Array(this.length());
-    const root = from !== undefined ? this.findNode(from) : this._head;
-
-    const storeInOrder = (node: BinarySearchNode<T> | null) => {
-      if (node === null) {
-        return;
-      }
-      storeInOrder(node.left);
-      array.push(node.data);
-      storeInOrder(node.right);
-    };
-
-    const storePostOrder = (node: BinarySearchNode<T> | null) => {
-      if (node === null) {
-        return;
-      }
-      storeInOrder(node.left);
-      storeInOrder(node.right);
-      array.push(node.data);
-    };
-
-    const storePreOrder = (node: BinarySearchNode<T> | null) => {
-      if (node === null) {
-        return;
-      }
-      array.push(node.data);
-      storeInOrder(node.left);
-      storeInOrder(node.right);
-    };
-
-    switch (type) {
-      case EnumTreeTraversalType.InOrder:
-        storeInOrder(root);
-        break;
-      case EnumTreeTraversalType.PostOrder:
-        storePostOrder(root);
-        break;
-      case EnumTreeTraversalType.PreOrder:
-        storePreOrder(root);
-        break;
-    }
-
-    return array.filter((item) => item !== undefined);
-  }
-
-  /**
-   * Calc max height of the largest branch of the tree
-   */
-  public height(): number {
-    const calcHeight = (node: BinarySearchNode<T>) => {
-      if (node === null) return 0;
-      const left: number = node.left === null ? -1 : calcHeight(node.left);
-      const right: number = node.right === null ? -1 : calcHeight(node.right);
-      const max = left > right ? left : right;
-      return max + 1;
-    };
-
-    if (this._head === null) {
-      return 0;
-    } else {
-      return calcHeight(this._head) + 1;
-    }
-  }
-}

package/src/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchNode.ts

@@ -1,48 +0,0 @@
-import BinarySearchNode from "../BinarySearchTree/BinarySearchNode";
-
-export default class RandBinarySearchNode<T> extends BinarySearchNode<T> {
-  private _rank: number;
-  protected _left: RandBinarySearchNode<T> | null;
-  protected _right: RandBinarySearchNode<T> | null;
-  protected _parent: RandBinarySearchNode<T> | null;
-
-  public constructor(initialData: T) {
-    super(initialData);
-    this._rank = 0;
-    this._left = null;
-    this._right = null;
-    this._parent = null;
-  }
-
-  public get rank(): number {
-    return this._rank;
-  }
-
-  public set rank(value: number) {
-    this._rank = value;
-  }
-
-  public get left(): RandBinarySearchNode<T> | null {
-    return this._left;
-  }
-
-  public set left(value: RandBinarySearchNode<T> | null) {
-    this._left = value;
-  }
-
-  public get right(): RandBinarySearchNode<T> | null {
-    return this._right;
-  }
-
-  public set right(value: RandBinarySearchNode<T> | null) {
-    this._right = value;
-  }
-
-  public get parent(): RandBinarySearchNode<T> | null {
-    return this._parent;
-  }
-
-  public set parent(value: RandBinarySearchNode<T> | null) {
-    this._parent = value;
-  }
-}

package/src/data-structures/BinaryTree/RandBinarySearchTree/RandBinarySearchTree.ts

@@ -1,228 +0,0 @@
-import { FnCompareTwo } from "../../../types/FnCompareTwo";
-import RandBinarySearchNode from "./RandBinarySearchNode";
-import BinarySearchTree from "../BinarySearchTree/BinarySearchTree";
-
-/**
- * Randomized binary search tree implementation
- */
-export default class RandBinarySearchTree<T> extends BinarySearchTree<T> {
-  /**
-   * Override types
-   */
-  protected _head: RandBinarySearchNode<T> | null;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(fnCompare?: FnCompareTwo<T>) {
-    super(fnCompare);
-    this._head = null;
-  }
-
-  /**
-   * Will update node rank by summing left and right subtrees tanks and itself rank (1)
-   */
-  private updateRank(node: RandBinarySearchNode<T>): void {
-    node.rank = (node.right?.rank || 0) + (node.left?.rank || 0) + 1;
-  }
-
-  /**
-   * Will set rank and parent attributes and update tree length
-   */
-  private addCreatedNode(
-    node: RandBinarySearchNode<T>,
-    parentNode: RandBinarySearchNode<T> | null = null
-  ): RandBinarySearchNode<T> {
-    node.rank = 1;
-    if (parentNode !== null) {
-      node.parent = parentNode;
-    }
-    return node;
-  }
-
-  /**
-   * Will rotate node to the right side
-   */
-  private rotateNodeRight(node: RandBinarySearchNode<T>): void {
-    const pivot = node.left;
-    if (pivot === null) {
-      return;
-    }
-    node.left = pivot.right;
-    if (pivot.right !== null) {
-      pivot.right.parent = node;
-    }
-    pivot.parent = node.parent;
-    if (node.parent === null) {
-      this._head = pivot;
-    } else {
-      if (node === node.parent.right) {
-        node.parent.right = pivot;
-      } else {
-        node.parent.left = pivot;
-      }
-    }
-    pivot.right = node;
-    node.parent = pivot;
-    this.updateRank(node);
-    this.updateRank(pivot);
-  }
-
-  /**
-   * Will rotate node to the left side
-   */
-  private rotateNodeLeft(node: RandBinarySearchNode<T>): void {
-    const pivot = node.right;
-    if (pivot === null) {
-      return;
-    }
-    node.right = pivot.left;
-    if (pivot.left !== null) {
-      pivot.left.parent = node;
-    }
-    pivot.parent = node.parent;
-    if (node.parent === null) {
-      this._head = pivot;
-    } else {
-      if (node === node.parent.left) {
-        node.parent.left = pivot;
-      } else {
-        node.parent.right = pivot;
-      }
-    }
-    pivot.left = node;
-    node.parent = pivot;
-    this.updateRank(node);
-    this.updateRank(pivot);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected join(
-    treeLeft: RandBinarySearchNode<T> | null,
-    treeRight: RandBinarySearchNode<T> | null
-  ): RandBinarySearchNode<T> | null {
-    if (treeLeft === null) {
-      return treeRight;
-    }
-    if (treeRight === null) {
-      return treeLeft;
-    }
-
-    if (Math.random() < treeLeft.rank / (treeLeft.rank + treeRight.rank)) {
-      treeLeft.right = this.join(treeLeft.right, treeRight);
-      if (treeLeft.right) {
-        this.updateLeftRightParents(treeLeft);
-      }
-      this.updateRank(treeLeft);
-      return treeLeft;
-    } else {
-      treeRight.left = this.join(treeLeft, treeRight.left);
-      if (treeRight.left) {
-        this.updateLeftRightParents(treeRight);
-      }
-      this.updateRank(treeRight);
-      return treeRight;
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected updateLeftRightParents(node: RandBinarySearchNode<T>): void {
-    super.updateLeftRightParents(node);
-    this.updateRank(node);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected insertToRoot(
-    createdNode: RandBinarySearchNode<T>,
-    fromNode?: RandBinarySearchNode<T>
-  ): void {
-    const recursiveInsert = (node: RandBinarySearchNode<T>) => {
-      if (this.compare(node.data, createdNode.data)) {
-        if (node.left === null) {
-          node.left = this.addCreatedNode(createdNode, node);
-        } else {
-          recursiveInsert(node.left);
-        }
-        this.rotateNodeRight(node);
-      } else {
-        if (node.right === null) {
-          node.right = this.addCreatedNode(createdNode, node);
-        } else {
-          recursiveInsert(node.right);
-        }
-
-        this.rotateNodeLeft(node);
-      }
-    };
-
-    if (this._head === null) {
-      this._head = this.addCreatedNode(createdNode);
-    } else {
-      fromNode ? recursiveInsert(fromNode) : recursiveInsert(this._head);
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected insertRandomly(createdNode: RandBinarySearchNode<T>): void {
-    const recursiveInsertRandomly = (node: RandBinarySearchNode<T>) => {
-      const shouldInsertToRoot = Math.random() < 1 / (node.rank + 1);
-
-      if (shouldInsertToRoot) {
-        this.insertToRoot(createdNode, node);
-      } else {
-        node.rank = node.rank + 1;
-
-        if (this.compare(node.data, createdNode.data)) {
-          if (node.left === null) {
-            node.left = this.addCreatedNode(createdNode, node);
-          } else {
-            recursiveInsertRandomly(node.left);
-          }
-        } else {
-          if (node.right === null) {
-            node.right = this.addCreatedNode(createdNode, node);
-          } else {
-            recursiveInsertRandomly(node.right);
-          }
-        }
-      }
-    };
-
-    if (this._head === null) {
-      this._head = this.addCreatedNode(createdNode);
-    } else {
-      recursiveInsertRandomly(this._head);
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public insert(value: T): void {
-    if (this.has(value)) {
-      throw new Error("Node already exists");
-    }
-    const createdNode = new RandBinarySearchNode(value);
-    this.insertRandomly(createdNode);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public delete(value: T): void {
-    super.delete(value);
-    this._length = this.length();
-  }
-
-  public length(): number {
-    return this._head?.rank || 0;
-  }
-}