Javascript Data Structure & Algorithms by miroo

class Node {
constructor(element)
    {
        this.element = element;
        this.next = null;
        this.previous = null;
    }
}
class LinkedList {
    constructor()
    {
        this.head = null; //root Node
        this.tail = null; // last element of the list
        this.size = 0;
    }
  
  //Adds element to the begining of the list. Similar to Array.unshift
  //O(1)
   addHead(value) {
    const newNode = new Node(value);

    newNode.next = this.head;

    if (this.head) {
      this.head.previous = newNode;
    } else {
      this.tail = newNode;
    }

    this.head = newNode; // update head
    this.size += 1;

    return newNode;
  }

    //Adds element to the end of the list (tail)
    //O(1)
    addTail(value) {
    const newNode = new Node(value);

    if (this.head) {
      newNode.previous = this.tail;
      this.tail.next = newNode;
      this.tail = newNode;
    } else {
      this.head = newNode;
      this.tail = newNode;
    }

    this.size += 1;

    return newNode;
  }
 
    // insert element at the position index of the list
    insertAt(element, index)
    {
	if (index < 0 || index > this.size)
		return console.log("Please enter a valid index.");
	else {
		// creates a new node
		var node = new Node(element);
		var curr, prev;

		curr = this.head;

		// add the element to the
		// first index
		if (index == 0) {
			node.next = this.head;
			this.head = node;
		} else {
			curr = this.head;
			var it = 0;

			// iterate over the list to find
			// the position to insert
			while (it < index) {
				it++;
				prev = curr;
				curr = curr.next;
			}

			// adding an element
			node.next = curr;
			prev.next = node;
		}
		this.size++;
	    }
     }

  //Removes element from the start of the list (head/root).
  //Runtime O(1)
   removeHead() {
    const head = this.head;

    if (head) {
      this.head= head.next;
      if (this.head) {
        this.head.previous = null;
      } else {
        this.tail = null;
      }
      this.size -= 1;
    }
    return head && head.value;
  }

   //Removes element to the end of the list. Similar to Array.pop
   //Runtime: O(1)
  removeTail() {
    const tail = this.tail;

    if (tail) {
      this.tail = tail.previous;
      if (this.tail) {
        this.tail.next = null;
      } else {
        this.head = null;
      }
      this.size -= 1;
    }
    return tail && tail.value;
  }

   // removes an element from the specified location
   removeFrom(index)
   {
    if (index < 0 || index >= this.size)
        return console.log("Please Enter a valid index");
    else {
        var curr, prev, it = 0;
        curr = this.head;
        prev = curr;
  
        // deleting first element
        if (index === 0) {
            this.head = curr.next;
        } else {
            // iterate over the list to the
            // position to removce an element
            while (it < index) {
                it++;
                prev = curr;
                curr = curr.next;
            }
  
            // remove the element
            prev.next = curr.next;
        }
        this.size--;
  
        // return the remove element
        return curr.element;
     }
   }

    // removes a given element from the list
    removeElement(element)
    {
	var current = this.head;
	var prev = null;

	// iterate over the list
	while (current != null) {
		// comparing element with current
		// element if found then remove the
		// and return true
		if (current.element === element) {
			if (prev == null) {
				this.head = current.next;
			} else {
				prev.next = current.next;
			}
			this.size--;
			return current.element;
		}
		prev = current;
		current = current.next;
	}
	return -1;
    }

    // finds the index of element
    indexOf(element)
   {
    var count = 0;
    var current = this.head;
  
    // iterae over the list
    while (current != null) {
        // compare each element of the list
        // with given element
        if (current.element === element)
            return count;
        count++;
        current = current.next;
    }
  
    // not found
    return -1;
   }

  
    isEmpty()
   {
    return this.size == 0;
   }

}

//FIFO(First in First Out) 
class Queue {
    // Array is used to implement Queue
    constructor()    {
        this.items = [];
    }  

    enqueue(element){  //O(1)
      this.items.push(element); 
    }

     //Removes an element from the front of a queue (items[0])
    dequeue(){ // O(n)       
      return this.items.shift();
    }
    peek(){
    // return the front element from the queue
    return this.items[0];
    }
    isEmpty(){
     // return true if queue is empty
    return this.items.length == 0;
   }
}

class Queue {
  constructor() {
    this.items = new LinkedList();
  }

   //Add element to the queue
   //Runtime: O(1)
  enqueue(item) {
    this.items.addTail(item);
    return this;
  }

 //Remove element from the queue
 //Runtime: O(1)
  dequeue() {
    return this.items.removeHead();
  }

  get size() {
    return this.items.size;
  }

  isEmpty() {
    return !this.items.size;
  }

//LIFO(Last in First Out) AND FILO(First in Last Out)
class Stack {
    // Array is used to implement stack
    constructor()    {
        this.items = [];
    }  

    push(element){  //O(1)
      this.items.push(element); 
    }

    pop(){ // O(1)
       return this.items.pop();
    }
    peek(){
    // return the top most element from the stack
    return this.items[this.items.length - 1];
    }
    isEmpty(){
     // return true if stack is empty
    return this.items.length == 0;
   }
}