一种递归算法，用于求数组中每个元素的和，其值小于x 我是一个C++初学者，我尝试编写一个递归算法，它返回数组中每个元素的总和，其值小于x.p/p>

这是我的密码：

#include <iostream>

using namespace std;

int sumOfElement(int xList[],int x, int lengthOfArray){
    int  sum = 0;
    if (lengthOfArray == 0)
        return sum;
    else
        for (int i=0; i <= lengthOfArray; i++) {
            if(xList[i] < x)
                return sum + xList[i];
            else
                sumOfElement(xList,x,lengthOfArray-1);
    }
}


int main() {
    cout << "Size of Array: ";
    int size; 
    cin >> size;
    int *xList = new int[size];

    //Inputing array.
    cout << "Enter elements of array followed by spaces: ";

    for (int i = 0; i<size; i++)
        cin >> xList[i]; 

    cout << "Enter the integer value of x: " <<endl;
    int limit;
    cin >> limit;

    cout << "Sum of every element in an array with a value less than x: " << sumOfElement(xList,limit,size) << endl;

    return 0;
}

#包括
使用名称空间std；
int-sumofe元素（int-xList[]，int-x，int-lengthOfArray）{
整数和=0；
if（lengthOfArray==0）
回报金额；
其他的
对于（int i=0；i尺寸；
int*xList=新的int[size]；
//输入数组。
cout xList[i]；
CUT <代码>（int i＝0；i）这里的方法不是真的递归。递归的思想是考虑一个基本情况，然后考虑如何在每一步减少问题直到到达基本情况。

对于此问题：


基本情况是当数组的长度为零时。在这种情况下，我们返回一个零和。（直观地说：如果数组为空，那么我们不添加任何内容，给出一个零和。）
为了减少我们的数组，我们查看数组的最后一个元素（即
lengthOfArray-1
）。我们处理这个元素：如果它小于
x
，我们添加它，如果它不是，我们忽略它。然后我们用同样的方法处理数组的其余部分（通过调用相同的函数，但使用不同的数组长度），并添加我们的结果（如果适用）

下面是一些示例代码：

int sumOfElement(int xList[], int x, int lengthOfArray){
    if (lengthOfArray == 0) {
        // base case
        return 0;
    } else {
        int value = xList[lengthOfArray-1];
        if (value < x) {
            // process the rest of the array and add our result
            return value + sumOfElement(xList, x, lengthOfArray - 1);
        } else {
            // process the rest of the array
            return sumOfElement(xList, x, lengthOfArray - 1);
        }
    }
}

int-sumofe元素（int-xList[]，int-x，int-lengthOfArray）{
if（lengthOfArray==0）{
//基本情况
返回0；
}否则{
int值=xList[lengthOfArray-1]；
如果（值
if（lengthOfArray=0）
看起来不对头
因为循环是迭代的一个例子，而不是递归。两者之间有严格的等价性，但它们不是一回事-它们可以实现相同的最终结果，但以不同的方式实现。递归没有显式循环-它有调用自己的函数（可能间接地，通过其他函数）。那么，如果你不再有循环，你的
i
来自哪里？还有
sum+xList[i]
如何处理数组的其余部分？编辑以避免使用
i
。仍然不正确，因为你的
xList[lengthOfArray-1]
仍不处理数组的其余部分。
sum
将不会随更改而设置为零以外的任何值。若要使用尾部递归，我将执行
value=（value
@Eugene这不是尾部递归。这是尾部递归模cons。我的函数实际上更为尾部递归（我的第二个else分支是尾部递归，而
值
案例是尾部递归模cons）。不管怎样：我都不打算在理解递归的这个层次上讨论尾部递归。（对于真正的尾部递归，这里需要一个累加器。）
int retVal = 0;
if(xList[lengthOfArray-1] < x)
    retval = xList[lengthOfArray-1]
return retVal + sumOfElement(xList,x,lengthOfArray-1);

int sumOfElement(int xList[], int x, int lengthOfArray){
    if (lengthOfArray == 0) {
        // base case
        return 0;
    } else {
        int value = xList[lengthOfArray-1];
        if (value < x) {
            // process the rest of the array and add our result
            return value + sumOfElement(xList, x, lengthOfArray - 1);
        } else {
            // process the rest of the array
            return sumOfElement(xList, x, lengthOfArray - 1);
        }
    }
}