在Java中使用递归的不同方式

Question

I'm thinking of several elegant ways of writing a simple Lisp-like recursive function in Java that does, let's say, a simple summation.

In Common Lisp it would be like this:

(defun summation(l)
    (if l
        (+ (car l) (summation (cdr l)))
        0))

(summation '(1 2 3 4 5)) ==> 15

In Java the one of many possible solutions would be:

public int summation(int[] array, int n) {
    return (n == 0)
            ? array[0]
            : array[n] + summation(array, n - 1);
}
CALL: 
summation(new int[]{1,2,3,4,5}, 4); //15

1) Is there any possible way NOT to use the index n?

2) Or leave your solution (non-iterational) which you see as interesting.

Thanks.

Answer 1

Using Java Collections - something like this should give you an idea of how to eliminate n and recurse in terms of the list size instead:

public int summation( List<Integer> list ) {
    return list.isEmpty()
        ? 0
        : list.get( list.size - 1 ) + summation( list.subList( 0 , list.size() - 1 )  );
}

Cheers,

Answer 2

Usually, I solve this kind of recursion with a public API that does not require the index parameter and a private API with any signature I#d like it to be. For this I would separate it this way:

public int summation(int[] numbers) {
    return summation(numbers, numbers.length - 1);
}

private int summation(int[] numbers, int till) {
    return (till < 0) ? 0 : numbers[till] + summation(numbers, till - 1);
}

Note that you must check till < 0 as this handles an empty array correctly.

---

Another way would be to not use an array, but any Iterable<Integer> :

public int summation(Iterable<Integer> numbers) {
    return summation(numbers.iterator());
}

private int summation(Iterator<Integer> numbers) {
    return (numbers.hasNext()) ? numbers.next() + summation(numbers) : 0;
}

Hint: The order of calls in numbers.next() + summation(numbers) is important, as the next() call must be done first.

Answer 3

If you use List.subList method, it may perform iteration, underneath. You can use Queue instead, to avoid iteration. For example:

public int sum(Queue queue) {
  return queue.isEmpty() ? 0 : (queue.poll() + sum(queue));
}

Answer 4

public class HelloWorld{


static int sum=0;
static int c;

     public static void main(String []args){

      int[] y={1,2,3,4,5};

      c=y.length;
     System.out.println( summation(y)); //15

     }

     public static int summation(int[] array) {

    c--;
    if(c<0){
        return sum;
           }
    else{
        sum+=array[c];
        return summation(array);

        }
}

}

Answer 5

Here's a simple method that seems pretty close to what's being asked for.Basically, we are taking a recursive approach to performing summation ascontrasted with brute force from the bottom up.

public static int sumToN(int n) {
    if( n == 0 ){
        return 0;
    }
    return n + sumToN(n - 1);
}