自定义链表高效移除所有指定元素实例的实现指南

public class employee {
    private String number;
    private String name;
    private int years;
    private String courseName;

    public employee(String number, String name, int years, String courseName) {
        this.number = number;
        this.name = name;
        this.years = years;
        this.courseName = courseName;
    }

    public String getCourseName() {
        return courseName;
    }

    // ... 其他 getter/setter 方法

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        employee other = (employee) obj;
        // 根据 courseName 进行比较
        if (courseName == null) {
            return other.courseName == null;
        } else {
            return courseName.equals(other.courseName);
        }
        // 如果需要根据所有属性比较，则需要包含所有属性的比较逻辑
        // return this.number.equals(other.number) && this.name.equals(other.name) && ...;
    }

    @Override
    public int hashCode() {
        // 重写 equals 方法通常也需要重写 hashCode 方法
        return (courseName != null ? courseName.hashCode() : 0);
    }
}

public class LinearNode<T> {
   private LinearNode<T> next;
   private T element;

   public LinearNode() {
      this.next = null;
      this.element = null;
   }

   public LinearNode (T elem) {
      this.next = null;
      this.element = elem;
   }

   public LinearNode<T> getNext() {
      return this.next;
   }

   public void setNext (LinearNode<T> node) {
      this.next = node;
   }

   public T getElement() {
      return this.element;
   }

   public void setElement (T elem) {
      this.element = elem;
   }
}

public class LinkedList<T> implements LinkedListADT<T> {
    private int count;
    private LinearNode<T> list; // pointer to the first element
    private LinearNode<T> last; // pointer to the last element

    public LinkedList() {
        this.count = 0;
        this.last = null;
        this.list = null;
    }

    // ... (add, remove, size 等其他方法)

    /**
     * 从链表中移除所有与指定元素匹配的实例。
     *
     * @param element 要移除的匹配元素。
     * @return 成功移除的元素数量。
     */
    public long clear(T element) {
        long removedCount = 0L; // 记录移除的元素数量

        LinearNode<T> current = this.list;    // 当前遍历的节点
        LinearNode<T> previous = null;        // 当前节点的前一个节点

        // 遍历链表直到末尾
        while (current != null) {
            // 使用 equals() 方法比较元素内容
            if (current.getElement().equals(element)) {
                // 匹配成功，执行移除操作

                if (previous != null) {
                    // 情况1：要移除的节点不是头节点
                    // 将前一个节点的 next 指针指向当前节点的下一个节点，从而跳过当前节点
                    previous.setNext(current.getNext());

                    // 如果当前节点是尾节点，更新 last 指针
                    if (current.getNext() == null) {
                        this.last = previous;
                    }
                } else {
                    // 情况2：要移除的节点是头节点
                    // 将链表头指针 list 指向当前节点的下一个节点
                    this.list = current.getNext();

                    // 如果链表在移除头节点后变为空，同时更新 last 指针为 null
                    if (this.list == null) {
                        this.last = null;
                    }
                }

                // 减少链表元素计数
                this.count--;
                // 增加移除计数
                removedCount++;

                // 移除当前节点后，current 应该指向 previous 的下一个节点（即刚刚跳过的节点），
                // 这样在下一次循环中 current 会指向正确的下一个待检查节点。
                // 如果 previous 为 null，说明头节点被移除，current 应指向新的 list 头。
                // 注意：这里可以利用循环末尾的 current = current.getNext() 来统一处理。
                // 当一个节点被移除时，current 仍然指向被移除的节点。
                // 循环末尾的 current = current.getNext() 会将 current 更新为被移除节点的下一个节点，这是正确的。
                // 因此，此处不需要额外的 current 更新逻辑。
            } else {
                // 不匹配，移动 previous 指针到当前节点
                previous = current;
            }

            // 移动 current 指针到下一个节点
            current = current.getNext();
        }

        return removedCount;
    }
}