如何在Java中递归地对节点中的项目求和？

Question

我正在尝试以迭代方式和递归方式总结节点中的项目。我已经编写了执行迭代方式的程序，但我在如何递归完成时遇到了问题。

代码：

public int sumIterative() {
    Node newNode= new Node(item, next);
    int sum = 0;

    while(newNode != null){
        sum = sum + item;
        newNode = newNode.next;
    }
    return sum;
}

我对递归方式的努力：

public int sumRecursive() {
    Node newNode = new Node(item,next);
    int sum = 0;
    int result;
    if(newNode == null){
        result = 0;
    } else {
        return sumRecursive();
    }
    return sum;    
}

我试图用“之后没有节点”的逻辑来做这个

这怎么可能递归完成？

编辑

这是公共驱动方法，我可以按需发布我的整个代码

public int sumRecursive() {
    int sum = 0;
    if (top != null) {
        sum = top.sumRecursive();
    }
    return sum;
}

class LinkedList {

    private class Node {
        public int item;
        public Node next;

        public Node(int newItem, Node newNext)  {
            item = newItem;
            next = newNext;
        }

        public int getItem() {
            return item;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node newNext) {
            next = newNext;
        }

        // My Other Node methods

        // Recursively add up the numbers stored in this
        // and all the nodes after this.
        // Base case: there are no nodes after this.
        public int sumRecursive() {
            Node node = new Node(item,next);

            /*Node newNode = new Node(item,next);
            int sum = 0;
            if (null == newNode) {
                return sum;
            } else {
                sum += sumRecursive(newNode.next);
            }*/

            if (node == null) {
                return node.item;
            } else {
                return node.item + sumRecursive(node.next);
            }
        }

        // Iteratively add up the numbers stored in this
        // and all the nodes after this.
        public int sumIterative() {
            Node newNode= new Node(item, next);
            int sum = 0;

            while(newNode != null) {
                sum = sum + item;
                newNode = newNode.next;
            }
            return sum;
        }
    } // end class Node

    private Node top; // a pointer to the first node in the list (when it's not empty)

    public LinkedList() {
        top = null; // empty list
    }

    // Insert a node at the front of the list
    public void insertAtFront(int newItem)  {
        top = new Node(newItem, top);
    }

    // Print out the list (10 numbers per line)
    public void printList() {
        int count = 1;
        Node curr;

        if (top == null) {
            System.out.println( "List is empty" );
        } else {
            curr = top;
            while (curr != null) {
                System.out.print( " " + curr.item );
                count++;
                if (count % 10 == 0) {
                    System.out.println();
                }
                curr = curr.next;
            }
            if (count % 10 != 0) {
                System.out.println();
            }
        }
    }

    // public driver method for sumRecursive
    public int sumRecursive() {
        int sum = 0;

        if (top != null) {
            sum = top.sumRecursive();
        }

        return sum;
    }

    // public driver method for sumIterative
    public int sumIterative() {
        int sum = 0;

        if (top != null) {
            sum = top.sumIterative();
        }

        return sum;
    }
} 

Answer 1

public int sumRecursive() {
  return sumRecursive(top);
}    

public int sumRecursive(Node node){
  if (node == null) {
    return 0;
  }
  return node.item + sumRecursive(node.next);
}

//或匹配你的驱动功能

public int sumRecursive() {
  if (top == null) {
    return 0;
  } else {
    return top.sumRecursive();
  }
}    

// in Node class    
public int sumRecursive(){ 
  int sum = this.item;  
  if (this.next != null) {
    sum += this.next.sumRecursive();
  }
  return sum;
}

Answer 2

    public int sumRecursive(Node node){
        if(node == null){
            return 0;
        }else{
            return node.item + sumRecursive(node.next);
        }   
    }