Java 尝试使用递归获得数组中偶数的和

我想得到数组中偶数的和：

 public static void main(String[] args) {
    int[] array = new int[4];
    array[0] = 1;
    array[1] = 2;
    array[2] = 2;
    array[3] = 4;

    System.out.println("Count even: " + countE(array, 0));      
 }   

public static int countE(int[] arr, int head) {
        if (arr.length == head) {
        return -1;
        } else if (arr[head] % 2 == 0) {              

            return 1 + countE(arr, head + 1);
    } else {

        return 0 + countE(arr, head + 1);
    }
}

给你带来了问题，兄弟。。。您正在从最终计数中减去1。。。试着做

if (arr.length == head) {
        return 0;

---

这可以通过递归来完成，因为您添加的数字是错误的

        else if (arr[head]%2==0)
        {
            return arr[head] +  countHead(arr, head + 1);
        }

---

它给你2，因为在上一个递归中，它扣除了1——你的基本情况是错误的。改为返回0。

我希望我没有向您透露太多，这会带走学习的兴奋

public static int countE(int[] array, int index) {
  int currentNumber = array[index];
  if(index == array.length) {
    // terminate it by returning a value that does not affect the sum (what integer is this?)
  } else {
    // check if even, if even, add the current number, else, add zero (both are recursive calls)
    if(isEven(currentNumber)) {
       return // your recursive call if even, currentNumber should be added
    } else {
       return // your recursive call if not, currentNumber should not be added
    }
  }
}

public static boolean isEven(int number) {
  return (number % 2 == 0) ? true : false;
}

Hlo。伙计。。试试这个

package com.smk.recursion;

public class SumOfEvenNoFromArray {
public static void main(String[] args) {

    int[] a = new int[5];
    a[0] = 2;
    a[1] = 5;
    a[2] = 4;
    a[3] = 4;
    a[4] = 4;

    System.out.println("Sum of Odd Numbers : "+sumEvenNoRecursion(a,(a.length-1)));

}

public static int sumEvenNoRecursion(int[] arr, int index){
    int sum;
    if(index == -1){
        return 0;
    }else if(arr[index]%2 == 0 ){           
        sum = arr[index] + sumEvenNoRecursion(arr, --index);            
    }else{
        sum =  sumEvenNoRecursion(arr, --index);            
    }
    return sum;


}
}

//输出

---

奇数之和：14

您可以在递归中使用辅助函数

public static int sumofEvens(int[] list){
    int sum = sumHelper(list, 0, 0);
    return sum;
}
private static int sumHelper(int[] list, int i, int sum){
    if(i < list.length){
        if(list[i] % 2 == 0){
            sum += list[i];
        }
        sum = sumHelper(list, i+1, sum);
    }
    return sum;
}

公共静态int-sumofeven（int[]列表）{
int sum=sumHelper（列表，0，0）；
回报金额；
}
私有静态int-sumHelper（int[]列表，int-i，int-sum）{
如果（i

输出应该给我偶数的计数，在我的主要方法中，我有一个长度为4的数组，有3个偶数。它给我的计数是2。为什么对线性问题使用递归？递归在这里是错误的方法。我应该在这里使用递归。（我们正在处理递归）粘贴完整的代码，包括数组和调用code@JimGarrison这里递归的美妙之处在于没有变异我在上一个elose语句中发现了问题。基本上我应该返回“arr[0]+countE（arr，head+1）@user2851858使用不同的输入重试；第一个元素类似于2，其他元素都是1。

public static int sumofEvens(int[] list){
    int sum = sumHelper(list, 0, 0);
    return sum;
}
private static int sumHelper(int[] list, int i, int sum){
    if(i < list.length){
        if(list[i] % 2 == 0){
            sum += list[i];
        }
        sum = sumHelper(list, i+1, sum);
    }
    return sum;
}