@raikuxq/alg-ds 1.1.2 → 1.1.5

package/src/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedList.ts

@@ -1,310 +0,0 @@
-import AbstractLinkedNode from "./AbstractLinkedNode";
-import ILinkedList from "../../../types/ILinkedList";
-
-export default 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) {
-    this._capacity = AbstractLinkedList.calculateCapacity(capacity);
-    this._head = null;
-    this._tail = null;
-    this._length = 0;
-  }
-
-  /**
-   * Will calculate real capacity value
-   * @throws when capacity <= 0
-   */
-  private static calculateCapacity(capacity?: number) {
-    if (capacity === undefined) {
-      return Number.MAX_VALUE;
-    }
-    if (capacity <= 0) {
-      throw new Error("Capacity must be larger than 0");
-    }
-
-    return capacity;
-  }
-
-  /**
-   * Will insert node between nodeLeft and nodeRight
-   * @throws when list is full
-   */
-  private insertNodeBetweenTwoNodes(
-    targetNode: AbstractLinkedNode<T>,
-    leftNode: AbstractLinkedNode<T> | null,
-    rightNode: AbstractLinkedNode<T> | null
-  ): void {
-    if (this.isFull()) {
-      throw new Error("List is full, no more space available");
-    }
-    if (this._head === null) {
-      this._head = targetNode;
-    }
-    if (this._tail === null) {
-      this._tail = targetNode;
-    }
-    if (!leftNode) {
-      leftNode = this._tail;
-    }
-    if (!rightNode) {
-      rightNode = this._head;
-    }
-
-    this.insertNodeBetweenTwoNodesImpl(targetNode, leftNode, rightNode);
-    this._length++;
-  }
-
-  /**
-   * Will remove the node from its neighbors nodes links
-   * @throws when node does not exist
-   */
-  private deleteNode(
-    node: AbstractLinkedNode<T> | null
-  ): AbstractLinkedNode<T> {
-    if (node === null) {
-      throw new Error("Node should be existed");
-    }
-    this.deleteNodeImpl(node);
-    this._length--;
-
-    if (this.isEmpty()) {
-      this.clear();
-    }
-    return node;
-  }
-
-  /**
-   * Will find node by its index
-   * @throws when node was not found
-   */
-  protected getNodeByIndex(index: number): AbstractLinkedNode<T> {
-    if (this.isEmpty()) {
-      throw new Error("List is empty");
-    }
-    if (this._length < index) {
-      throw new Error("Index exceed list length");
-    }
-
-    let currentNode = this._tail;
-    let counter = 0;
-
-    while (currentNode && counter < index) {
-      currentNode = currentNode.next;
-      counter++;
-    }
-
-    if (currentNode === null) {
-      throw new Error("Node does not exist");
-    }
-
-    return currentNode;
-  }
-
-  /**
-   * 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
-   */
-  public unshift(value: T): void {
-    const node = this.createNode(value);
-    this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
-    this._tail = node;
-  }
-
-  /**
-   * Push into end
-   */
-  public push(value: T): void {
-    const node = this.createNode(value);
-    this.insertNodeBetweenTwoNodes(node, this._head, this._tail);
-    this._head = node;
-  }
-
-  /**
-   * Push from index
-   */
-  public pushFromIndex(value: T, fromIndex: number): void {
-    const isIndexNotInRange = fromIndex < 0 || fromIndex > this._length;
-    const shouldPushAsFirst = this.isEmpty() && fromIndex === 0;
-
-    if (isIndexNotInRange) {
-      throw new Error("index must be in range between 0 and list length");
-    }
-    if (shouldPushAsFirst) {
-      this.push(value);
-    } else {
-      const node = this.createNode(value);
-      const nodeLeft = this.getNodeByIndex(fromIndex - 1);
-      const nodeRight = this.getNodeByIndex(fromIndex);
-      this.insertNodeBetweenTwoNodes(node, nodeLeft, nodeRight);
-    }
-  }
-
-  /**
-   * Delete node from list's end
-   */
-  public pop(): T {
-    const deletedNode = this.deleteNode(this._head);
-    this.popImpl();
-    return deletedNode.data;
-  }
-
-  /**
-   * Delete node from list's start and get its data
-   */
-  public shift(): T {
-    const deletedNode = this.deleteNode(this._tail);
-    this.shiftImpl();
-    return deletedNode.data;
-  }
-
-  /**
-   * Delete node from list by index from start
-   */
-  public deleteFromIndex(fromIndex: number): T {
-    const nodeToDelete = this.getNodeByIndex(fromIndex);
-    const deletedNode = this.deleteNode(nodeToDelete);
-    return deletedNode.data;
-  }
-
-  /**
-   * List length
-   */
-  public length(): number {
-    return this._length;
-  }
-
-  /**
-   * Is list empty
-   */
-  public isEmpty(): boolean {
-    return this._length === 0;
-  }
-
-  /**
-   * Is list full
-   */
-  public isFull(): boolean {
-    return this._length >= this._capacity;
-  }
-
-  /**
-   * Check if element exists in list
-   */
-  public has(item: T): boolean {
-    return this.getAsArray().includes(item);
-  }
-
-  /**
-   * Get head element data
-   * @throws Error when head does not exist
-   */
-  public peek(): T {
-    if (!this._head) {
-      throw new Error("Head does not exist");
-    }
-
-    return this._head.data;
-  }
-
-  /**
-   * Get tail element data
-   * @throws Error when tail does not exists
-   */
-  public peekFromStart(): T {
-    if (!this._tail) {
-      throw new Error("Tail does not exist");
-    }
-
-    return this._tail.data;
-  }
-
-  /**
-   * Get list element by index from start
-   * @throws when element does not exist
-   */
-  public peekByIndex(index: number): T {
-    const node = this.getNodeByIndex(index);
-    return node.data;
-  }
-
-  /**
-   * Remove all elements from list
-   */
-  public clear(): void {
-    this._head = null;
-    this._tail = null;
-    this._length = 0;
-  }
-
-  /**
-   * Get elements as an array
-   */
-  public getAsArray(): Array<T> {
-    const array: Array<T> = [];
-    let currentNode = this._tail;
-    let counter = 0;
-
-    while (currentNode && counter < this._length) {
-      if (currentNode) array.push(currentNode.data);
-
-      currentNode = currentNode.next;
-      counter++;
-    }
-
-    return array;
-  }
-
-  /**
-   * Add elements to list from array
-   * @throws when list is full
-   * */
-  public pushFromArray(elements: Array<T>): void {
-    elements.forEach((element: T) => {
-      if (this.isFull()) {
-        throw new Error("List is full, no more space available");
-      }
-      this.push(element);
-    });
-  }
-
-  /**
-   * Reverse list nodes links and swap head with tail
-   * @example "4>7>10" will be reversed to "10>7>4"
-   */
-  public abstract reverse(): void;
-}

package/src/data-structures/LinkedList/AbstractLinkedList/AbstractLinkedNode.ts

@@ -1,33 +0,0 @@
-export default 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 = null) {
-    this._data = data;
-    this._next = next;
-  }
-
-  /**
-   * Get data of node
-   */
-  public get data(): T {
-    return this._data;
-  }
-
-  /**
-   * Get next node link
-   */
-  public get next(): AbstractLinkedNode<T> | null {
-    return this._next;
-  }
-
-  /**
-   * Set next node link
-   */
-  public set next(value: AbstractLinkedNode<T> | null) {
-    this._next = value;
-  }
-}

package/src/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedList.ts

@@ -1,156 +0,0 @@
-import IBiDirectIterator from "../../../types/IBiDirectIterator";
-import IBiDirectIterable from "../../../types/IBiDirectIterable";
-import AbstractLinkedList from "../AbstractLinkedList/AbstractLinkedList";
-import DoubleLinkedNode from "./DoubleLinkedNode";
-
-/**
- * Linear data structure
- * Each node has next and prev sibling
- * Head and tail are linked to each other
- */
-export default class DoubleLinkedList<T>
-  extends AbstractLinkedList<T>
-  implements IBiDirectIterable<T> {
-  /**
-   * Override types
-   */
-  protected _head: DoubleLinkedNode<T> | null;
-  protected _tail: DoubleLinkedNode<T> | null;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(capacity?: number) {
-    super(capacity);
-    this._head = null;
-    this._tail = null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected createNode(value: T): DoubleLinkedNode<T> {
-    return new DoubleLinkedNode<T>(value);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected insertNodeBetweenTwoNodesImpl(
-    targetNode: DoubleLinkedNode<T>,
-    leftNode: DoubleLinkedNode<T>,
-    rightNode: DoubleLinkedNode<T>
-  ): void {
-    targetNode.next = rightNode;
-    targetNode.prev = leftNode;
-
-    if (targetNode.prev) {
-      targetNode.prev.next = targetNode;
-    }
-    if (targetNode.next) {
-      targetNode.next.prev = targetNode;
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected deleteNodeImpl(node: DoubleLinkedNode<T>): void {
-    node!.prev!.next = node!.next;
-    node!.next!.prev = node!.prev;
-    node!.next = null;
-    node!.prev = null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected popImpl(): void {
-    this._head = this._tail?.prev || null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected shiftImpl(): void {
-    this._tail = this._head?.next || null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public reverse(): void {
-    let currentNode = this._tail;
-    let i = 0;
-
-    while (currentNode && i < this._length) {
-      const newPrev = currentNode.next;
-      const newNext = currentNode.prev;
-
-      currentNode.prev = newPrev;
-      currentNode.next = newNext;
-
-      i++;
-      currentNode = newNext;
-    }
-
-    if (currentNode) {
-      this._tail = currentNode.next;
-      this._head = currentNode;
-    }
-  }
-
-  /**
-   * List iterator
-   */
-  public iterator(fromIndex = 0): IBiDirectIterator<T> {
-    const head = this._head;
-    const tail = this._tail;
-    let activeNode = this.getNodeByIndex(fromIndex) as DoubleLinkedNode<T>;
-
-    const iterator: IBiDirectIterator<T> = {
-      /**
-       * @inheritDoc
-       */
-      current: () => {
-        return activeNode.data;
-      },
-      /**
-       * @inheritDoc
-       */
-      hasNext(): boolean {
-        return Boolean(activeNode.next) && activeNode !== head;
-      },
-      /**
-       * @inheritDoc
-       */
-      hasPrev(): boolean {
-        return Boolean(activeNode.prev) && activeNode !== tail;
-      },
-      /**
-       * @inheritDoc
-       * @throws when next element does not exist
-       */
-      next: (): T => {
-        if (!iterator.hasNext()) {
-          throw new Error("Next element does not exist");
-        }
-        activeNode = activeNode.next!;
-        return activeNode.data;
-      },
-      /**
-       * @inheritDoc
-       * @throws when prev element does not exists
-       */
-      prev: (): T => {
-        if (!iterator.hasPrev()) {
-          throw new Error("Prev element does not exist");
-        }
-        activeNode = activeNode.prev!;
-        return activeNode.data;
-      },
-    };
-
-    return iterator;
-  }
-}

package/src/data-structures/LinkedList/DoubleLinkedList/DoubleLinkedNode.ts

@@ -1,47 +0,0 @@
-import AbstractLinkedNode from "../AbstractLinkedList/AbstractLinkedNode";
-
-export default class DoubleLinkedNode<T> extends AbstractLinkedNode<T> {
-  protected _prev: DoubleLinkedNode<T> | null;
-  protected _next: DoubleLinkedNode<T> | null;
-
-  /**
-   * Will create empty node
-   */
-  public constructor(
-    data: T,
-    next: DoubleLinkedNode<T> | null = null,
-    prev: DoubleLinkedNode<T> | null = null
-  ) {
-    super(data);
-    this._prev = prev;
-    this._next = next;
-  }
-
-  /**
-   * Set previous node link
-   */
-  public set prev(value: DoubleLinkedNode<T> | null) {
-    this._prev = value;
-  }
-
-  /**
-   * Get previous node link
-   */
-  public get prev(): DoubleLinkedNode<T> | null {
-    return this._prev;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public set next(value: DoubleLinkedNode<T> | null) {
-    this._next = value;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public get next(): DoubleLinkedNode<T> | null {
-    return this._next;
-  }
-}

package/src/data-structures/LinkedList/SingleLinkedList/SingleLinkedList.ts

@@ -1,147 +0,0 @@
-import IIterator from "../../../types/IIterator";
-import IIterable from "../../../types/IIterable";
-import AbstractLinkedList from "../AbstractLinkedList/AbstractLinkedList";
-import SingleLinkedNode from "./SingleLinkedNode";
-
-/**
- * Linear data structure
- * Each node has next
- * Head's next node is tail
- */
-export default class SingleLinkedList<T>
-  extends AbstractLinkedList<T>
-  implements IIterable<T> {
-  /**
-   * Override types
-   */
-  protected _head: SingleLinkedNode<T> | null;
-  protected _tail: SingleLinkedNode<T> | null;
-
-  /**
-   * @inheritDoc
-   */
-  public constructor(capacity?: number) {
-    super(capacity);
-    this._head = null;
-    this._tail = null;
-  }
-
-  /**
-   * Find previous sibling of given node
-   */
-  private getPrevNode(
-    node: SingleLinkedNode<T> | null
-  ): SingleLinkedNode<T> | null {
-    let currentNode = this._tail;
-    while (currentNode?.next !== node) {
-      currentNode = currentNode?.next || null;
-    }
-    return currentNode;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected createNode(value: T): SingleLinkedNode<T> {
-    return new SingleLinkedNode<T>(value);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected insertNodeBetweenTwoNodesImpl(
-    targetNode: SingleLinkedNode<T>,
-    leftNode: SingleLinkedNode<T>,
-    rightNode: SingleLinkedNode<T>
-  ): void {
-    targetNode.next = rightNode;
-
-    if (leftNode) {
-      leftNode.next = targetNode;
-    }
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected deleteNodeImpl(node: SingleLinkedNode<T>): void {
-    this.getPrevNode(node)!.next = node.next;
-    node.next = null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected popImpl(): void {
-    this._head = this.getPrevNode(this._tail);
-  }
-
-  /**
-   * @inheritDoc
-   */
-  protected shiftImpl(): void {
-    this._tail = this._head?.next || null;
-  }
-
-  /**
-   * @inheritDoc
-   */
-  public reverse(): void {
-    let currentNode: SingleLinkedNode<T> | null = this._tail;
-    let prevNode: SingleLinkedNode<T> | null = this._head;
-    let index = 0;
-
-    while (index < this._length) {
-      const next = currentNode?.next || null;
-
-      if (currentNode) {
-        currentNode.next = prevNode;
-      }
-
-      index++;
-      prevNode = currentNode;
-      currentNode = next;
-    }
-
-    if (currentNode) {
-      this._head = currentNode;
-      this._tail = currentNode.next;
-    }
-  }
-
-  /**
-   * List iterator
-   */
-  public iterator(fromIndex = 0): IIterator<T> {
-    const head = this._head;
-    let activeNode: SingleLinkedNode<T> = this.getNodeByIndex(fromIndex);
-
-    const iterator: IIterator<T> = {
-      /**
-       * @inheritDoc
-       */
-      current: () => {
-        return activeNode.data;
-      },
-      /**
-       * @inheritDoc
-       */
-      hasNext(): boolean {
-        return Boolean(activeNode.next) && activeNode !== head;
-      },
-      /**
-       * @inheritDoc
-       * @throws when next element does not exist
-       */
-      next: (): T => {
-        if (!iterator.hasNext()) {
-          throw new Error("Next element does not exist");
-        }
-        activeNode = activeNode.next!;
-        return activeNode.data;
-      },
-    };
-
-    return iterator;
-  }
-}