Javascript 从链表中删除奇数/偶数

这是一个包含数据和下一个属性的标准链接列表

这就是我正在尝试的：

class Node {
    constructor(data, next) {
        this.data = data;
        this.next = next;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }

    insertFirst(data) {
        this.head = new Node(data, this.head);
    }

    size() {
        let counter = 0, node = this.head;

        while (node) {
            counter++;
            node = node.next;
        }

        return counter;
    }

    toArray() {
        let node = this.head;
        const result = [];

        while (node) {
            result.push(node.data);
            node = node.next;
        }

        return result;
    }


    removeEven() {
        let previous = this.head;
        let node = this.head.next;

        if (this.isEven(previous.data)) {
            console.log('outside loop, found one: ' + previous.data)
            this.head = this.head.next;
        }

        while (node) {
            if (this.isEven(node.data)) { 
                console.log('found ' + node.data); 
                previous.next = node.next;
            }

            node = node.next;
        }

    }

    isEven(num) { return num % 2 === 0 ? true : false; }
}

const q = new LinkedList();
q.insertFirst(16)
q.insertFirst(3)
q.insertFirst(4)
q.insertFirst(7)
q.insertFirst(5)
q.insertFirst(2)
q.insertFirst(1)
q.insertFirst(15)
q.insertFirst(18)
q.removeEven();

console.log(q.toArray());

以及输出：

outside loop, found one: 18
found 2
found 4
found 16
[ 15, 1, 2, 5, 7, 4, 3, 16 ] 

所以它只删除第一个值，它在循环之外，如何删除其他值

---

编辑：添加了完整的代码，但是，它要求我添加更多的文本，除了我已经添加的内容之外，我没有更多的内容要添加。

您应该更新循环中以前的

类节点{
构造函数（数据，下一个）{
这个数据=数据；
this.next=next；
}
}
类链接列表{
构造函数（）{
this.head=null；
}
insertFirst（数据）{
this.head=新节点（数据，this.head）；
}
大小（）{
设计数器=0，
node=this.head；
while（节点）{
计数器++；
node=node.next；
}
返回计数器；
}
toArray（）{
让node=this.head；
常量结果=[]；
while（节点）{
结果推送（节点数据）；
node=node.next；
}
返回结果；
}
removeEven（）{
让previous=this.head；
让node=this.head.next；
if（此.isEven（先前的.data））{
console.log（'外部循环，找到一个：'+上一个.data）
this.head=this.head.next；
}
while（节点）{
if（this.isEven（node.data））{
console.log（'found'+node.data）；
previous.next=node.next；
}否则{
上一个=节点；
}
node=node.next；
}
}
removeOdd（）{
让previous=this.head；
让node=this.head.next；
如果（！this.isEven（先前的.data））{
console.log（'外部循环，找到一个：'+上一个.data）
this.head=this.head.next；
}
while（节点）{
如果（！this.isEven（node.data））{
console.log（'found'+node.data）；
previous.next=node.next；
}否则{
上一个=节点；
}
node=node.next；
}
}
伊塞文（数字）{
返回数值%2==0？真：假；
}
}
const q=新的LinkedList（）；
q、 插入第一（16）
q、 插入第一（3）
q、 插入第一（4）
q、 插入第一（7）
q、 插入第一（5）
q、 插入第一（2）
q、 insertFirst（1）
q、 插入第一（15）
q、 插入第一（18）
q、 removeOdd（）；
console.log（q.toArray（））
您应该更新循环中的
上一个


类节点{
构造函数（数据，下一个）{
这个数据=数据；
this.next=next；
}
}
类链接列表{
构造函数（）{
this.head=null；
}
insertFirst（数据）{
this.head=新节点（数据，this.head）；
}
大小（）{
设计数器=0，
node=this.head；
while（节点）{
计数器++；
node=node.next；
}
返回计数器；
}
toArray（）{
让node=this.head；
常量结果=[]；
while（节点）{
结果推送（节点数据）；
node=node.next；
}
返回结果；
}
removeEven（）{
让previous=this.head；
让node=this.head.next；
if（此.isEven（先前的.data））{
console.log（'外部循环，找到一个：'+上一个.data）
this.head=this.head.next；
}
while（节点）{
if（this.isEven（node.data））{
console.log（'found'+node.data）；
previous.next=node.next；
}否则{
上一个=节点；
}
node=node.next；
}
}
removeOdd（）{
让previous=this.head；
让node=this.head.next；
如果（！this.isEven（先前的.data））{
console.log（'外部循环，找到一个：'+上一个.data）
this.head=this.head.next；
}
while（节点）{
如果（！this.isEven（node.data））{
console.log（'found'+node.data）；
previous.next=node.next；
}否则{
上一个=节点；
}
node=node.next；
}
}
伊塞文（数字）{
返回数值%2==0？真：假；
}
}
const q=新的LinkedList（）；
q、 插入第一（16）
q、 插入第一（3）
q、 插入第一（4）
q、 插入第一（7）
q、 插入第一（5）
q、 插入第一（2）
q、 insertFirst（1）
q、 插入第一（15）
q、 插入第一（18）
q、 removeOdd（）；
console.log（q.toArray（））您已经非常接近了，需要保留对上次更新值的引用


类节点{
构造函数（数据，下一个）{
这个数据=数据；
this.next=next；
}
}
类链接列表{
构造函数（）{
this.head=null；
}
insertFirst（数据）{
this.head=新节点（数据，this.head）；
}
大小（）{
设计数器=0，
node=this.head；
while（节点）{
计数器++；
node=node.next；
}
返回计数器；
}
toArray（）{
让node=this.head；
常量结果=[]；
while（节点）{
结果推送（节点数据）；
node=node.next；
}
返回结果；
}
removeEven（）{
让电流=这个头；
让我们最终；
while（当前.下一个）{
if（this.isEven（current.data））{
当前=当前。下一步；
}否则{
如果（！最终）{
最终=当前
this.head=final
}否则{
final.next=当前
最终=当前
}
当前=当前。下一步
}
}
if（this.isEven（current.data））{
final.next=null
}
}
伊塞文（数字）{
返回数值%2==0？真：假；
}
}
const q=新的LinkedList（）；
q、 插入第一（16）
q、 插入第一（3）
q、 插入第一（4）
q、 插入第一（7）
q、 插入第一（5）
q、 插入第一（2）
q、 insertFirst（1）
q、 插入第一（15）
q、 插入第一（18）
q、 removeEven（）；
console.log（q.toArray（））您已经非常接近了，需要保留对上次更新值的引用


类节点{
构造函数（数据，下一个）{
这个数据=数据；
this.next=next；
}
}
类链接列表{
构造函数（）{
this.head=null；
}
insertFirst（数据）{
this.head=新节点（数据，this.head）；
}
大小（）{
设计数器=0，
node=this.head；
while（节点）{
计数器++；
node=node.next；
}
返回计数器；
}
toArray（）{
让node=this.head；
常量结果=[]；
while（节点）{
结果推送（节点数据）；
node=node.next；
}
返回结果；
}
removeEven（）{
让电流=这个头；
让