递归查找数组中偶数的平均值

Question

我试图使用递归找到数组中所有偶数的平均值，但我陷入了困境。

我意识到对于每个奇数 n都必须递减 n因此我用正确的值除以，但是我无法确定如何使用递归进行计算。

考虑到当我return时它将恢复原状，因此我不了解如何跟踪n 。

有什么方法可以让我追踪n ，或者我完全以错误的方式看待这个问题吗？

编辑：我应该指定，我需要专门使用递归。 这是一项任务。

public static int getEvenAverage(int[] A, int i, int n)
{
    // first element
    if (i == 0)
        if (A[i] % 2 == 0)
            return A[0];
        else
            return 0;

    // last element
    if (i == n - 1)
    {
        if (A[i] % 2 == 0)
            return (A[i] + getEvenAverage(A, i - 1, n)) / n;
        else
            return (0 + getEvenAverage(A, i - 1, n)) / n;
    }

    if (A[i] % 2 == 0)
        return A[i] + getEvenAverage(A, i - 1, n);
    else
        return 0 + getEvenAverage(A, i - 1, n);
}

Answer 1

为了跟踪到目前为止您所遇到的偶数，只需传递一个额外的参数即可。

此外，您还可以为偶数之和传递一个额外的参数，当您遇到基本情况时，您可以返回平均值，即偶数之和除以它们的计数。

还有一件事，您的代码对于第一个和最后一个元素都有两个基本用例，它们是不需要的。

1. 您可以递减n （从数组的大小开始，直到第一个元素），或者
2. 您可以从0开始递增i ，直到达到array的大小，即n 。

在这里，我尝试过。

public static int getEvenAvg(int[] a, int n, int ct, int sum) {
    if (n == -1) {
        //make sure you handle the case
        //when count of even numbers is zero
        //otherwise you'll get Runtime Error.
        return sum/ct;
    }
    if (a[n]%2 == 0) {
        ct++;
        sum+=a[n];
    }
    return getEvenAvg(a, n - 1, ct, sum); 
}

您可以像这样调用函数getEvenAvg(a, size_of_array - 1, 0, 0);

例

Answer 2

在处理递归操作时，从终止条件开始通常很有用。 那么我们这里的终止条件是什么？

没有更多要处理的元素：

if (index >= a.length) {
    // To avoid divide-by-zero
    return count == 0 ? 0 : sum / count;
}

...好吧，现在我们如何减少要处理的元素数量？ 我们应该增加索引吗？

index++;

...哦，但是只有在进入下一个级别时：

getEvenAverage(elements, index++, sum, count);

好了，我们也不得不加入到sum和count ，对不对？

sum += a[index];
count++;

....除非仅当元素为偶数时：

if (a[index] % 2 == 0) {
    sum += a[index];
    count++;    
}    

...就是这样：

static int getEvenAverage(int[] elements, int index, int sum, int count) {
    if (index >= a.length) {
        // To avoid divide-by-zero
        return count == 0 ? 0 : sum / count;
    }

    if (a[index] % 2 == 0) {
        sum += a[index];
        count++;    
    } 

    return getEvenAverage(elements, index + 1, sum, count);
}

...尽管您可能希望包装器函数使其更漂亮：

static int getEvenAverage(int[] elements) {
    return getEvenAverage(elements, 0, 0, 0);
}

Answer 3

说明

这里的困难是您需要记住两个值 ：

• 偶数的数量和
• 偶数累加的总值。

并且您需要返回一个平均值的最终值。

这意味着您需要一次记住三个值，而只能返回一个元素。

---

大纲

对于干净的设计，您需要某种容器来保存这些中间结果，例如，像这样的类：

public class Results {
    public int totalValueOfEvens;
    public int amountOfEvens;

    public double getAverage() {
        return totalValueOfEvens + 0.0 / amountOfEvens;
    }
}

当然，您也可以使用带有两个条目的int[]类的东西。

之后，递归非常简单。 您只需要递归遍历数组，例如：

public void method(int[] values, int index) {
    // Abort if last element
    if (index == values.length - 1) {
        return;
    }

    method(array, index + 1);
}

同时，使用当前值更新容器 。

---

向后收集

向后收集时，您需要将所有信息存储在返回值中 。

由于要记住许多事情，因此应使用容器作为返回类型（ Results或2 -entry int[] ）。 然后简单地走到最后，收集并返回。

它看起来像这样：

public static Results getEvenAverage(int[] values, int curIndex) {
    // Traverse to the end
    if (curIndex != values.length - 1) {
        results = getEvenAverage(values, curIndex + 1);
    }

    // Update container
    int myValue = values[curIndex];

    // Whether this element contributes
    if (myValue % 2 == 0) {
        // Update the result container
        results.totalValueOfEvens += myValue;
        results.amountOfEvens++;
    }

    // Return accumulated results
    return results;
}

---

收集转发

此方法的优点在于，调用者无需自己调用results.getAverage() 。 您将信息存储在参数中，因此可以自由选择返回类型。

我们获取当前值并更新容器。 然后，我们调用下一个元素，并将当前容器传递给他。

调用最后一个元素后，保存在容器中的信息将是最终信息。 现在，我们只需要结束递归并返回第一个元素。 再次访问第一个元素时，它将根据容器中的信息计算最终输出并返回。

public static double getEvenAverage(int[] values, int curIndex, Results results) {
    // First element in recursion
    if (curIndex == 0) {
        // Setup the result container
        results = new Results();
    }

    int myValue = values[curIndex];

    // Whether this element contributes
    if (myValue % 2 == 0) {
        // Update the result container
        results.totalValueOfEvens += myValue;
        results.amountOfEvens++;
    }

    int returnValue = 0;
    // Not the last element in recursion
    if (curIndex != values.length - 1) {
        getEvenAverage(values, curIndex + 1, results);
    }

    // Return current intermediate average,
    // which is the correct result if current element
    // is the first of the recursion
    return results.getAverage();
}

---

最终用户的使用

向后方法的用法如下：

Results results = getEvenAverage(values, 0);
double average results.getAverage();

而正向方法的用法如下：

double average = getEvenAverage(values, 0, null);

当然，您可以使用辅助方法将其隐藏给用户：

public double computeEvenAverageBackward(int[] values) {
    return getEvenAverage(values, 0).getAverage();
}

public double computeEvenAverageForward(int[] values) {
    return getEvenAverage(values, 0, null);
}

然后，对于最终用户，这只是此调用：

double average = computeEvenAverageBackward(values);

Answer 4

Java不是用于这种事情的好语言，但是我们开始：

public class EvenAverageCalculation {

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(getEvenAverage(array));
    }

    public static double getEvenAverage(int[] values) {
        return getEvenAverage(values, 0, 0);
    }

    private static double getEvenAverage(int[] values, double currentAverage, int nrEvenValues) {
        if (values.length == 0) {
            return currentAverage;
        }
        int head = values[0];
        int[] tail = new int[values.length - 1];
        System.arraycopy(values, 1, tail, 0, tail.length);
        if (head % 2 != 0) {
            return getEvenAverage(tail, currentAverage, nrEvenValues);
        }
        double newAverage = currentAverage * nrEvenValues + head;
        nrEvenValues++;
        newAverage = newAverage / nrEvenValues;
        return getEvenAverage(tail, newAverage, nrEvenValues);
    }
}

您将当前平均值和到目前为止的偶数元素传递给每个递归调用。 通过将平均值再次乘以到目前为止的元素数，再加上新的单个值，然后将其除以新的元素数，即可计算出新的平均值，然后再将其传递给下一个递归调用。

为每个递归调用重新创建新数组的方式对Java来说并不是很好。 还有其他语言具有用于拆分数组的头部和尾部的语法，该语法还具有较小的内存占用空间（每个递归调用都会导致创建一个具有n-1个元素的新int数组）。 但是我实现的方式是函数式编程的经典方式（至少在1994年，我与编程语言Gofer进行了类似的分配时才学会它；-)

Answer 5

这是另一个变体，对平均值使用（中等）众所周知的递归关系：

平均₀ = 0

平均_n =平均_n-1 +（x _n-平均_n-1 ）/ n

其中avg _n是n ^个观测值的平均值，x _n是第n ^个观测值。 这导致：

/*
 * a is the array of values to process
 * i is the current index under consideration
 * n is a counter which is incremented only if the current value gets used
 * avg is the running average
 */
private static double getEvenAverage(int[] a, int i, int n, double avg) {
   if (i >= a.length) {
      return avg;
   }
   if (a[i] % 2 == 0) {         // only do updates for even values
      avg += (a[i] - avg) / n;  // calculate delta and update the average
      n += 1;
   }
   return getEvenAverage(a, i + 1, n, avg);
 }

可以使用以下前端方法来调用该方法，以保护用户无需了解参数初始化：

public static double getEvenAverage(int[] a) {
   return getEvenAverage(a, 0, 1, 0.0);
}

Answer 6

现在换一种完全不同的方法。

这其中借鉴了事实，如果你有两个平均值，平均₁基于N + _1组的意见和平均₂基于N ₂的观察，你可以将它们结合起来，以产生一个汇集平均：

平均_池 =（n ₁ * avg ₁ + n ₂ * avg ₂ ）/（n ₁ + n ₂ ）。

这里唯一的问题是递归函数应该返回两个值，即平均值和该平均值所基于的观测值的数量。 在许多其他语言中，这不是问题。 在Java中，它需要一些琐碎的助手类（尽管有些烦人）形式的黑客：

   // private helper class because Java doesn't allow multiple returns
   private static class Pair {
      public double avg;
      public int n;

      public Pair(double avg, int n) {
         super();
         this.avg = avg;
         this.n = n;
      }      
   }

应用分而治之策略产生以下递归：

   private static Pair getEvenAverage(int[] a, int first, int last) {
      if (first == last) {
         if (a[first] % 2 == 0) {
            return new Pair(a[first], 1);
         }
      } else {
         int mid = (first + last) / 2;
         Pair p1 = getEvenAverage(a, first, mid);
         Pair p2 = getEvenAverage(a, mid + 1, last);
         int total = p1.n + p2.n;
         if (total > 0) {
            return new Pair((p1.n * p1.avg + p2.n * p2.avg) / total, total);
         }
      }
      return new Pair(0.0, 0);
    }

我们可以处理空数组，保护最终用户不必了解簿记参数，并通过使用以下公共前端仅返回平均值：

   public static double getEvenAverage(int[] a) {
      return a.length > 0 ? getEvenAverage(a, 0, a.length - 1).avg : 0.0;
   }

该解决方案的好处是，对于n个项目的阵列，O（log n）堆栈的增长较之于已提出的各种其他解决方案的O（n）有所提高。 结果，它可以处理更大的数组，而不必担心堆栈溢出。