Question

当递归算法不能始终到达每个级别的所有函数时，该术语是什么？请考虑以下代码：

function f(value):
    if val < -10 return g(value + 1)
    if var > 10 return h(value - 1)
    else return 0

function g(value):
    if value % 2 == 0 return f(value / 2)
    else return h(value)

function h(value):
    if value % 2 == 1 return g(value - 1)
    else return h(value - 1)

每次递归调用都可以调用不同的函数，例如当我们从15开始时：

f(15)
  h(14)
    h(13)
      g(12)
        f(6)
          return 0

Answer 1

我从未听说过您描述的具体术语，它只是简称为递归。

它为某些递归级别执行可能不同的路径这一事实并没有真正使它变得特殊，不仅仅是循环中的相同功能：

#include <iostream>
#include <math.h>
#include <stdio.h>      /* printf, scanf, puts, NULL */
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */
#include <vector>
#include <boost/timer/timer.hpp>
using namespace std;

void experiment(std::vector<double> &myVector) {
    // Computing L2 norm squared
    double normSq(0);
    double wallClockTime1;
    double total(0); //fake variable
    for (int add = 1; add <= 256; add = add * 2) {
        normSq = 0;
        boost::timer::cpu_timer timer;
        for (unsigned int i = 0; i < myVector.size(); i = i + add) {
            normSq += myVector[i] * myVector[i];
        }
        boost::timer::cpu_times elapsed = timer.elapsed();
        if (add == 1) {
            wallClockTime1 = elapsed.wall / 1e9; // we save how long it took if we use every coordinate
        }

        //we print how long it took to compute the sum of squares if we take only each  "add" coordinate
        cout <<"for add = "<< add << " took " << elapsed.wall / 1e9
                <<" was "<< wallClockTime1 / (elapsed.wall / 1e9) << "times faster "
          << endl;
        total += normSq;
    }
    cout << total << endl;
}

int main() {

    /* initialize random seed: */
    srand(time(NULL));
    // generate random vector
    std::vector<double> myVector(100000000); //allocate vector of size 100000000 doubles
    for (unsigned int i = 0; i < myVector.size(); i++) {
        myVector[i] = rand() / (RAND_MAX + 0.0); //set each coordinate to a random number
    }

    experiment(myVector); //run experiment

    return 0;
}

这仍然被称为循环（不是像＃34;交替循环＆＃34;或＆＃34;依赖于迭代的行为循环＆＃34;）。它类似于递归示例。

实际上，递归始终在至少一个级别（最后一个级别）中具有不同的行为，因为没有它，它将永远重复，并且您很可能会溢出堆栈。

递归而不在每次递归调用上执行所有方法

1 个答案: