LinkedList - Creating function that takes a value, creates a node, and add it to end of list

Question

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.

Answer 1

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; }

Answer 2

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);