整数数组和的分治算法

Question

我在使用分而治之的算法时遇到了一些麻烦，正在寻求帮助。我正在尝试编写一个名为 sumArray 的函数来计算整数数组的总和。

这个函数必须通过将数组分成两半并在每一半上执行递归调用来完成。我尝试使用与我在编写递归求和算法和分治算法来识别数组中的最大元素时使用的概念相似的概念，但我正在努力将这两个想法结合起来。

下面是我为 sumArray 编写的代码，它可以编译，但不会返回正确的结果。

int sumArray(int anArray[], int size)
{
    int total = 0;
    //base case
    if (size == 0)
    {
        return 0;
    }
    else if (size == 1)
    {
        return anArray[0];
    }

    //divide and conquer
    int mid = size / 2;
    int lsum = anArray [mid] + sumArray(anArray, --mid);
    int rsize = size - mid;
    int rsum = anArray[size - mid] + sumArray(anArray + mid, --rsize);
    return lsum + rsum;
}

我发现问题在于函数在计算 rsum 时包含了 lsum 的值。我知道问题在于我使用 rsize （一个等于原始数组大小减去中点的变量）对 sumArray 的递归调用。但是，出于某种原因，我似乎无法确定修复方法。

我觉得这个问题很愚蠢，因为我知道答案就在眼前，但是如何修复我的函数以使其返回准确的结果？

更新：感谢所有有用的回复，我已经修复了我的代码，以便它可以很好地编译和运行。我将把我的原始代码留在这里，以防其他人在分而治之的情况下苦苦挣扎，并且可能会犯类似的错误。有关正确解决问题的功能，请参阅@Laura M 的答案。 @haris 的回复也很好地解释了我的代码在哪里出错。

Answer 1

int sumArray(int anArray[], int size)
{
    //base case
    if (size == 0)
    {
        return 0;
    }
    else if (size == 1)
    {
        return anArray[0];
    }

    //divide and conquer
    int mid = size / 2;
    int rsize = size - mid;
    int lsum = sumArray(anArray, mid);
    int rsum = sumArray(anArray + mid, rsize);
    return lsum + rsum;
}

Answer 2

在您的代码中：

int mid = size / 2;
int lsum = anArray [mid] + sumArray(anArray, --mid);
int rsize = size - mid;
int rsum = anArray[size - mid] + sumArray(anArray + mid, --rsize);

我们可以通过数组为{ 2, 3, 4, 5, 6, 9} 和size = 6 的示例来说明错误。

现在当你做mid = size / 2，然后是：

int lsum = anArray [mid] + sumArray(anArray, --mid);
int rsize = size - mid;
int rsum = anArray[size - mid] + sumArray(anArray + mid, --rsize);

数字5 被添加两次（一次在lsum 中，然后在rsum 中），因为mid == (size - mid)。

此外，rsum 中对sumArray() 的调用应该有参数sumArray(anArray + (mid + 1), --rsize) 作为元素mid 已经添加到lsum 中

另一方面，您可以使用更简单的递归代码，例如..

int add(int low,int high,int *a)
{
    int mid;
    if(high==low)
        return a[low];
    mid=(low+high)/2;
    return add(low,mid,a)+add(mid+1,high,a);
}

Answer 3

int sumArray(int anArray[],int start,int end){
     if(start==end)
        return anArray[start];
     if(start<end){
         int mid=(start+end)/2;
         int lsum=sumArray(anArray,start,mid-1);
         int rsum=sumArray(anArray,mid+1,end);
         return lsum+rsum+anArray[mid];

     }
     return 0;

}

Answer 4

正如哈里斯所说，在您的代码中，您将相同的数字添加到右和左和；但是，您的代码存在更大的问题。

你总是将相同的数组传递给你对 lsum 和 rsum 的递归调用。起初我认为这只是您实现的一部分，它会由 size 参数处理。但是，size 参数似乎无法正常工作，因为您可能希望它正常工作。 您的算法所做的只是减小 size 参数，直到它达到 1。然后，触发基本情况，结果始终返回原始数组中的第一项。为什么？您永远不会在代码中分解数组，因此相同的数组会在每个递归调用中持续存在（即使在基本情况下）。

要解决这个问题，所有 sumarray() 应该做的就是根据中间计算将数组拆分为左半部分和右半部分，并递归传递这个新数组，直到数组的大小为 1（基本情况）然后您返回数组中的项目。这有效地将数组分解为各个元素，此时函数所要做的就是将 lsum 和 rsum 相加。

伪代码：

sumArray(array[]){
    if size(array) is 1
          return array[0]

    mid = size(array) / 2 
    leftArray = splitArrayUpto(mid, array)
    rightArray = splitArrayAfter(mid+1, array)

    leftArraySum = sumArray(leftArray)
    rightArraySum = sumArray(rightArray)

    return leftArraySum + rightArraySum
 }   

Answer 5

#include<iostream>
using namespace std;
int sum(int a[], int l, int r)
{
    if(l==r) return a[l];
    int mid = (l+r)/2;
    int lsum = sum(a,l,mid);
    int rsum = sum(a,mid+1,r);
    return lsum+rsum;
}

int main() {
    int b[] = {9,7,2,6,5,3};
    int fsum = sum(b,0,5);
    cout<<fsum;
    return 0;
}

Answer 6

int a[mx], tree[mx*3];

void sum(int node, int s, int e){
  if(s == e)
  {
     tree[node] = a[s];
     return;
  }

  int left = node*2;
  int right = node*2 + 1;
  int mid = (s+e)/2;

  sum(left, s, mid);
  sum(right, mid+1, e);

  tree[node] = tree[left] + tree[right];
}

cin >> n;
for(int i=1;i<=n;i++)
    cin >> a[i];

sum(1, 1, n);

Full Code Here