Btukfyl

This is the pseudocode we have to build the LL from:

FUNCTION push(element)

CREATE node

SET node.value TO element

SET node.next TO null



IF the head node does not exist

THEN SET head to node

ELSE

SET current to head

SET current.next to node

END IF

END FUNCTION

The pseudocode itself has an error in it as well.

Below is my attempt to follow that, but right now it's pointing
to the { right after value in the push function.

let head = null,

last,

node,

current,

value = element;



const linkedList = () => {

 let node = new Node(value);



 push(value) {

   if(head === null) {

       head = last = node;

   } else {

       last.next = node;

       last = node;

   }

  }

 }

Error : push(value) { <----- This curly bracket is throwing the error. Unexpected token.

Beside the syntax error, you have a logical error as well. You need to treat the head node different from any other node and set the head property to node if not set, but if set, then assign to the last node the next node.

If you no head node, you can not set the last node, because there is actually no one.

class Node {

    constructor(value) {

        this.value = value;

        this.next = null;

    }

}



class LinkedList {

    constructor() {

        this.head = null;

        this.last = null;

    }

    push(value) {

        var node = new Node(value);

        if (!this.head) {

            this.head = node;

        } else {

            this.last.next = node;

        }

        this.last = node;

    }

}



var ll = new LinkedList;



ll.push(10);

console.log(ll);



ll.push(11);

console.log(ll);



ll.push(12);

console.log(ll);

.as-console-wrapper { max-height: 100% !important; top: 0; }

With check for an already inserted value.

class Node {

    constructor(value) {

        this.value = value;

        this.next = null;

    }

}



class LinkedList {

    constructor() {

        this.head = null;

        this.last = null;

    }

    push(value) {

        var node = new Node(value),

            temp = this.head;

        

        while (temp) {

            if (temp.value === value) return;

            temp = temp.next;

        }



        if (!this.head) {

            this.head = node;

        } else {

            this.last.next = node;

        }

        this.last = node;

    }

}



var ll = new LinkedList;



ll.push(10);

console.log(ll);



ll.push(11);

console.log(ll);



ll.push(12);

console.log(ll);



ll.push(11);

console.log(ll);

.as-console-wrapper { max-height: 100% !important; top: 0; }

And since we are at it.
Here is a version where you can insert append and remove nodes in ES6. No last node thougth since that would ruin the beauty of it. :)

class Node {

    constructor(value) {

        this.prev = null;

        this.next = null;

        this.value = value === undefined? null : value;

        this.list = null;

    }

    remove() {

        let prev = this.prev;

        let next = this.next;

        if (prev) {

            prev.next = next;

        }

        if (next) {

            next.prev = prev;

        }

        return this;

    }

    insert(node) {

        let prev = this.prev;

        if (prev) {

            prev.next = node;

            node.prev = prev;

        }

        this.prev = node;

        node.next = this;

    }

    append(node) {

        let next = this.next;

        if (next) {

            next.prev = node;

            node.next = next;

        }

        this.next = node;

        node.prev = this;

    }

}

class LinkedList {

    constructor() {

        this.head = null;

    }

    get last() {

        return this.list.length > 0 ? this.list[this.list.length] : null;

    }

    get values() {

        let node = this.head;

        let values = ;

        while(node) {

            values.push(node.value);

            node = node.next;

        };

        return values;

    }



    push(node) {

        node.prev = null;

        node.next = null;

        if (this.head) {

            this.head.prev = node;

            node.next = this.head;

        }

        this.head = node;

    }

    find(v) {

        let node = this.head;

        let fn = v;

        if (!(v instanceof Function)) fn = (el) => el.value === v;

        while(node && !fn(node)) {node = node.next;};

        return node;

    }

    forEach(fn) {

        let node = this.head;

        while(node) {fn(node); node = node.next;};

    }

}

Usable like so:

let ll = new LinkedList();

let n1= new Node(1);

let n2= new Node(2);

let n3= new Node(3);

ll.push(n1);

ll.push(n2);

ll.find(1).append(n3);

console.log(ll.values);

ll.find(3).remove();

console.log(ll.values);

ll.find(2).append(n3);

console.log(ll.values);