实现SinglyList<T>单链表类增加的void removeAll(T key)方法，public权限，查找并删除所有与key相等的元素结点

### 回答1：
非常好的问题！以下是一个可能的实现示例：

template<typename T>
class SinglyList {
public:
    struct Node {
        T data;
        Node* next;
        Node(T data) : data(data), next(nullptr) {}
    };
    
    Node* head;
    
    SinglyList() : head(nullptr) {}
    
    void removeAll(T key) {
        Node* cur = head;
        Node* prev = nullptr;
        
        while(cur != nullptr) {
            if(cur->data == key) {
                Node* next = cur->next;
                if(prev == nullptr) {
                    head = next;
                } else {
                    prev->next = next;
                }
                delete cur;
                cur = next;
            } else {
                prev = cur;
                cur = cur->next;
            }
        }
    }
    
    void addFront(T data) {
        Node* newNode = new Node(data);
        newNode->next = head;
        head = newNode;
    }
};

该方法遍历链表，查找所有与key相等的节点，并删除它们。要注意，当我们删除节点时，我们需要更新prev指针，以便在后续遍历中正确链接节点。

希望这个答案能对你有所帮助！

### 回答2：
实现`SinglyList<T>`单链表类的`removeAll(T key)`方法如下：

public class SinglyList<T> {
    private Node<T> head; // 单链表头结点
    // ...

    // 单链表节点类
    private static class Node<T> {
        private T data; // 数据
        private Node<T> next; // 下一个节点

        public Node(T data) {
            this.data = data;
            this.next = null;
        }
    }

    //...

    // 移除单链表中所有与key相等的元素节点
    public void removeAll(T key) {
        if (head == null) {  // 空链表，直接返回
            return;
        }

        Node<T> previous = null; // 当前节点的前一个节点
        Node<T> current = head; // 当前节点
        while (current != null) {
            if (current.data.equals(key)) {  // 找到相等的节点
                if (previous == null) {  // 如果是头结点
                    head = current.next;  // 更新头结点
                } else {
                    previous.next = current.next;  // 删除当前节点
                }
            } else {
                previous = current;  // 前一个节点指向当前节点
            }
            current = current.next; // 当前节点指向下一个节点
        }
    }

    // ...
}

这个方法通过遍历单链表，并比较节点数据与给定`key`的值，找到相等的节点后删除。如果要删除的节点是头结点，则将头结点更新为下一个节点；如果是中间或尾部节点，则将前一个节点的`next`指针指向下一个节点，从而删除当前节点。

这样，调用`removeAll`方法后，单链表中所有与给定`key`相等的节点都被删除了。

### 回答3：
实现SinglyList<T>单链表类增加的void removeAll(T key)方法，需要遍历链表，查找并删除所有与key相等的元素节点。具体实现如下：

public class SinglyList<T> {
    private Node<T> head;  // 头节点

    // 定义节点类
    private static class Node<T> {
        private T data;
        private Node<T> next;

        public Node(T data) {
            this.data = data;
        }
    }

    // ...

    // 添加其他方法和构造函数

    // 删除链表中所有与key相等的元素节点
    public void removeAll(T key) {
        Node<T> prev = null;  // 当前节点的前一个节点
        Node<T> current = head;  // 当前节点

        while (current != null) {
            if (current.data.equals(key)) {  // 如果找到与key相等的元素节点
                if (prev == null) {  // 如果是头节点
                    head = current.next;
                } else {
                    prev.next = current.next;
                }
            } else {  // 如果不相等，向后遍历
                prev = current;
            }
            current = current.next;
        }
    }
}

这样我们就可以通过调用`removeAll`方法来删除链表中所有与给定key相等的元素节点了。例如，如果我们有以下链表：

1 -> 2 -> 3 -> 2 -> 4

我们调用`removeAll(2)`方法后，链表将变为：

1 -> 3 -> 4