linkedlist.ts

class SingleLinkedList {
  private counts = 0;
  private head: SingleNode | null = null;

  constructor() {}

  get(index: number): number {
    const invalidIndex = index + 1 > this.counts;
    const noHead = this.isNull(this.head);
    if (invalidIndex || noHead) {
      return -1;
    }
    let result = -1;
    let loopNode = this.head as SingleNode;
    let tempIndex = 0;
    while (tempIndex <= index) {
      if (tempIndex === index) {
        result = loopNode.val;
        tempIndex = index + 1;
      } else if (loopNode.next) {
        loopNode = loopNode.next;
      }
      tempIndex += 1;
    }
    return result;
  }

  addAtHead(val: number): void {
    if (this.isNull(this.head)) {
      const newHead = new SingleNode(val, null);
      this.head = newHead;
      this.counts += 1;
      return;
    }
    const originalHead = this.head;
    const newHead = new SingleNode(val, originalHead);
    this.head = newHead;
    this.counts += 1;
  }

  addAtTail(val: number): void {
    if (this.isNull(this.head)) {
      this.addAtHead(val);
      return;
    }
    const newNode = new SingleNode(val, null);
    let loopNode = this.head as SingleNode;
    while (loopNode.next) {
      loopNode = loopNode.next;
    }
    loopNode.next = newNode;
    this.counts += 1;
  }

  addAtIndex(index: number, val: number): void {
    if (index === 0) {
      this.addAtHead(val);
      return;
    }
    if (index > this.counts) {
      return;
    }

    let preNode = this.head as SingleNode;
    let preNodeIndex = 0;
    while (preNodeIndex < index) {
      if (preNodeIndex + 1 === index) {
        const preNodeNext = preNode.next;
        const newNode = new SingleNode(val, preNodeNext);
        preNode.next = newNode;
        this.counts += 1;
        preNodeIndex = index;
      } else if (preNode.next) {
        preNode = preNode.next;
      }
      preNodeIndex += 1;
    }
  }

  deleteAtIndex(index: number): void {
    if (!this.head || index >= this.counts) {
      return;
    }
    if (index === 0) {
      const newHead = this.head.next;
      this.head = newHead;
      this.counts -= 1;
      return;
    }

    let preNode = this.head as SingleNode;
    let preNodeIndex = 0;
    while (preNodeIndex < index) {
      if (preNodeIndex + 1 === index) {
        const deletedNode = preNode.next;
        const newNextNode = deletedNode ? deletedNode.next : null;
        if (deletedNode) {
          deletedNode.next = null;
        }
        preNode.next = newNextNode;
        this.counts -= 1;
        preNodeIndex = index;
      } else if (preNode.next) {
        preNode = preNode.next;
      }
      preNodeIndex += 1;
    }
  }

  private isNull(val): boolean {
    return val === null;
  }
}

class SingleNode {
  constructor(val: number, next: SingleNode | null) {
    this.val = val;
    this.next = next;
  }
  val: number;
  next: SingleNode | null;
}

/**
 * SingleLinkedList object will be instantiated and called as such:
 * var obj = new SingleLinkedList()
 * var param_1 = obj.get(index)
 * obj.addAtHead(val)
 * obj.addAtTail(val)
 * obj.addAtIndex(index,val)
 * obj.deleteAtIndex(index)
 */