Question

你好我正在学习递归，目前我有几个技巧问题要解剖 - 这里是一个递归函数

int rec(int niz[], int start, int end){

if (start == end)
{

    return niz[start]; // vraca zadnji
}

int temp = rec(niz, start+1, end);


// control output
cout << "\n-----\n";
cout << "start "  << start << endl;
cout << "niz[start] "  << niz[start] << endl;
cout << "end "  << end << endl;
cout << "temp "  << temp << endl;
cout << "\n-----------------------------------------\n";
//contrl output end

return ((niz[start] < temp) ? niz[start] : temp);
}

我包含了一个cout块来控制调用中的功能。这是主要部分

    int niz[] = {1,2,3,4,5,6,7}; 
    cout << rec(niz, 0, 3);

这是我的输出：

-----
start 2
niz[start] 3
end 3
temp 4
------------------

----- 
start 1
niz[start] 2
end 3
temp 3
------------------

-----
start 0
niz[start] 1
end 3
temp 2
------------------

1

任何人都可以解释我如何计算和返回临时值以及我如何获得1作为此函数的返回值？

提前谢谢你！

Answer 1

递归函数是调用自身的函数。

int temp = rec(niz, start+1, end);

在这里你可以在一个内部调用“rec”函数，但是使用更改的参数（start + 1）。你可以在彼此内部调用这些函数，直到“start”等于“end”（然后它返回）

if (start == end)
{

    return niz[start]; // vraca zadnji
}

在最深的一个返回后，第二个最深的一个继续流动，打印一些信息。

cout << "\n-----\n";
cout << "start "  << start << endl;
cout << "niz[start] "  << niz[start] << endl;
cout << "end "  << end << endl;
cout << "temp "  << temp << endl;
cout << "\n-----------------------------------------\n";

然后它返回niz [start]和temp（本地值）之间的最低值。

return ((niz[start] < temp) ? niz[start] : temp);

然后第三个最深的一个继续流动，依此类推。直到它进入第一个功能。

在你的主要部分你将结尾设置为3，所以它对前3个元素执行操作（它到达第四个元素，但除了返回它的值之外什么都不做）。通过比较你作为开始传递的niz [0]和递归函数返回的temp（恰好相同）得到1。它等于，所以返回值是niz [0]，即1;

使用递归函数时，应该有某种“退出点”阻止递归变为无限，即

if (start == end)
{   
    return niz[start];
}

通常，递归函数如下所示：

f()
{
    //return condition
    //some work
    f();
    //some work
    //return
}

你可以把它们视为这个

f()
{
    //some code
    f()
    {
        //some code
        f()
        {
            //some code
            f()
            {
                ...
                //eventually the return condition is met
            }
            //some code
            //return
        }
        //some code
        //return
    }
    //some code
    //return
}

请注意，未处理的递归可能会导致内存泄漏，因为每个函数调用都附带了额外的数据。

f()
{
    f();
}

由于已创建的系统数据，这将导致堆栈溢出;

您可能希望观看“Inception”以更好地理解它：）

Answer 2

您的递归行位于print语句块之前。根据递归的性质，它使函数调用该递归行并停止调用函数的执行，直到被调用者完成。因此，在打印当前元素之前，需要处理下一个元素。

在您的示例中，发生以下情况：

Layer 1:
    Is start equal to end? No.
    What is the result of the next element? Don't know yet, recurse.
Layer 2:
    Is start equal to end? No.
    What is the result of the next element? Don't know yet, recurse.
Layer 3:
    Is start equal to end? No.
    What is the result of the next element? Don't know yet, recurse.
Layer 4:
    Is start equal to end? Yes!
    Return the current element, 4.
    End layer 4.
Layer 3:
    Now know next element, start printing for the 3rd element.
    Return 3.
    End layer 3.
Layer 2:
    Now know the next element, start printing for the 2nd element.
    Return 2.
    End layer 2.
Layer 1:
    Now know the next element, start printing for the 1st element.
    Return 1.
    End layer 1.
End program.

如您所见，数组元素向后打印，因为print语句在递归调用之后。我希望它们按顺序打印，在递归调用之前打印它们，或者创建一个缓冲区并将每个打印部分附加到缓冲区的前面。

Answer 3

 rec(niz, 0, 3)                          (D)
  |
  ---->rec(niz, 1, 3)                    (C)
        |
        ----> rec(niz, 2, 3)             (B)
               |
               ----> rec(niz, 3, 3)      (A)

你打电话给（D）调用（C）来计算temp，依此类推，直到（A）。 在（A） start==end中，它会返回niz[3] = 4。

在（B）中：

temp = 4（（A）的结果）

start = 2

当4大于niz[start] = 3时（B）返回3

在（C）中：

temp = 3（（B）的结果）

start = 1

当3大于niz[start] = 2时（B）返回2

在（D）中：

temp = 2（（C）的结果）

start = 0

当2大于niz[start] = 1时（B）返回1

c ++递归数组解释

3 个答案:

在（B）中：

在（C）中：

在（D）中：