实现计数发生方法的Listnode问题（递归）

Question

您好，我正在尝试实现ListNode，但我对这两种方法都遇到了问题

• [contains(E data)，它接受一个通用对象并检查其在列表中的存在。

• countIf(E data)接受一个通用对象，并检查它在ListNode中的出现。

我知道可以用迭代的方法来实现，但是我想进行递归操作，所以请告诉我我做错了什么：

public class ListNode2<E> {

    public E data;

    public ListNode2<E> next;

    public ListNode2(){
        this.data=null;
        this.next=null;
    }
    public ListNode2(E data, ListNode2<E> n) {
        this.data = data;
        next= n;
    }

    public ListNode2(E data) {
        this.data = data;
        next=null;
    }

    public E getData() {
        return this.data;
    }

    public ListNode2<E> getNext() {
        return this.next;
    }

    public ListNode2<E> addFirst(E data) {
        return new ListNode2<>(data, this);
    }
    public boolean contains(E data){

        if ( data ==null && this.getData()==null )
            return true;

        if (data!=null && (data.equals(this.getData())))
            return true;

        if (this.next==null)//remove the next and we have nullpointer exception but right results :( 
            return false;

        return this.getNext().contains(data);
    }    

    public int countIf(E data) {

        if (data ==null && this.getData() == null )
            return 1+ getNext().countIf(data);

        if ( data!= null && (data.equals(this.getData())) )
            return 1 + getNext().countIf(data);

        if(this==null)
            return 0;


        return getNext().countIf(data);
    }

    public int size() {
        if (getNext() == null) {
            return 1;
        } else {
            return 1 + getNext().size();
        }
    }

    @Override
    public String toString() {
        return data + " ";
    }

    public static void main(String[] args) {

        ListNode2<Integer> list = null; // Leere Liste.
        list = new ListNode2<Integer>(1); // ergibt 1.
        list = list.addFirst(2);
        list = list.addFirst(3);
        list = list.addFirst(4);
        int size = list.size();

        System.out.println(size);

        System.out.println("countif 1 "+ list.countIf(1));
        System.out.println("countif 2 "+ list.countIf(2));
        System.out.println("countif 3 "+ list.countIf(3));
        System.out.println("countif 5 "+ list.countIf(5));
        System.out.println("countif null "+ list.countIf(null));
        System.out.println("countif 7 "+ list.countIf(7));
    }
}

countCount方法中我在做什么错？我似乎无法弄清楚吗？

编辑：更正了用户建议的contains方法：Ole V.V。。但在

上应用相同的提示

Answer 1

与您执行检查的顺序有关。

    public boolean contains(E data){

        if (this.next==null)//remove the next and we have nullpointer exception but right results :( add the 
            return false;

        if ( data ==null && this.getData()==null )
            return true;

        if (data!=null && (data.equals(this.getData())))
            return true;

        return this.getNext().contains(data);
    }    

现在，如果要搜索的数据元素在最后一个节点中，会发生什么？首先，您检查next是否为null。它是。因此，您返回false。您永远不会发现数据在同一节点中。

相反，您需要在内容的两次检查之后放置null检查（当然，仍然包含递归调用的return语句之前。）>

countIf()的情况非常相似。

顺便说一下，不错的代码。