!Data structure

Stack
Queue
Singly linked list

https://github.com/trekhleb/javascript-algorithms/blob/master/src/data-structures

Queue

class Queue {
  constructor() {
    this.oldestIndex = 1;
    this.newestIndex = 1;
    this.storage = {};
  }
  
  size() {
    return this.newestIndex - this.oldestIndex;
  }
  
  enqueue(data) {
    this.storage[this.newestIndex] = data;
    this.newestIndex++;
  }
  
  dequeue() {
    let deletedData;

    if (this.oldestIndex !== this.newestIndex) {
        deletedData = this.storage[this.oldestIndex];
        delete this.storage[this.oldestIndex];
        this.oldestIndex++;

        return deletedData;
    }
  }
}

Singly linked list

class SinglyList {
  constructor() {
    this.lenght = 0;
    this.head = null;
    this.errorMessage = {failure: 'Failure: non-existent node in this list.'};
  }
  
  add(value) {
    let node = {
      data: value,
      next: null
    }
    let currentNode = this.head;    
    
    if(!currentNode) {
      this.head = node;
      this.lenght++;
      
      return node;
    }
    
    // find last node
    while (currentNode.next) {
      currentNode = currentNode.next;
    }
    
    currentNode.next = node;
    this.lenght++;
   
    return node;
  }
  
  findNodeAt(position) {
    let currentNode = this.head;
    let count = 1;
    
    if (this.lenght === 0 || position < 0 || position > this.lenght) {
      throw new Error(this.errorMessage.failure);
    }
    
    while(count < position) {
      currentNode = currentNode.next;
      count++;
    }
    
    return currentNode;
  }
  
  remove(position) {
    let currentNode = this.head;
    let count = 0;
    let beforeNodeToDelete = null;
    let nodeToDelete = null;
    let deletedNode = null;
    
    if (position < 0 || position > this.lenght) {
      throw new Error(this.errorMessage.falure);
    }
    
    // first node deleted
    if (position === 1) {
      this.head = currentNode.next;
      deletedNode = currentNode;
      currentNode = null;
      this.lenght--;
      
      return deletedNode;
    }
    
    // other nodes deleted
    while(count < position) {
      beforeNodeToDelete = currentNode;
      nodeToDelete = currentNode.next;
      currentNode = currentNode.next;
      count++;
    }
    
    beforeNodeToDelete.next = nodeToDelete.next;
    deletedNode = nodeToDelete;
    nodeToDelete = null;
    this.lenght--;
    
    return deletedNode;
  }
}

Stack

class Stack {
  constructor() {
    this.size = 0;
    this.storage = {};
  }
  
  push(data) {
    ++this.size;
    this.storage[this.size] = data;
  }
  
  pop() {
    let deletedData;
    
    if (this.size) {
        deletedData = this.storage[this.size];

        delete this.storage[this.size];
        this.size--;

        return deletedData;
    }
  }
}