Question

我正在尝试确定几种算法的大O复杂性，并且我无法理解如何推理以下代码：

void recursiveFunc (n)
{
   for(int i = 0; i < 8; i++)
   {
       if (n < maxN)
       {
           recursiveFunc (n + 1);
       }
       else
       {
           for(int j = 0; j < 8; j++)
           {
              // do some stuff
           }
       }
   }
}

我认为这是一个指数因为递归函数在循环内部被调用。 O（8 ^ N）？但是我对如何推理它有点迷茫。

Answer 1

你的提示是正确的。

鉴于代码：

var maxN = 16;
var initN = 0;
var count = 0;
function recursiveFunc (n) {
    for(var i = 0; i < 8; i++) {
        if (n < maxN) {
                recursiveFunc (n + 1);
        } else {
            for(int j = 0; j < 8; j++) {
                count++;
            }
        }
    }
}
recursiveFunc(initN);

首次调用n = 0：

8 ^ 1次调用recursiveFunc（其中n = 1）

调用n = 1然后导致：8 ^ 2次调用recursiveFunc

...

使用n =（maxN - 1）调用然后导致：8 ^ maxN次调用recursiveFunc =＆gt;访问其他分支，每个电话进入＆＃34;一些东西＆＃34; 64次

首次调用n = 2，maxN = 4：

8 ^ 1次调用recursiveFunc（其中n = 3）

调用n = 3然后导致：8 ^ 2次调用recursiveFunc（其中n = 4）

调用n = 4然后访问else分支，每次64次。

因此输入＆＃34;某些东西的总数量为＃34;阶段：64 *（8 ^（maxN - initN））

O（8 ^ N）

编辑：你可以在这里看到这个，只需点击＆＃34;运行代码片段＆＃34;然后点击＆＃34;测试＆＃34;按钮。（尝试更大的maxN值可能会导致浏览器崩溃）

＆＃13;

function test () {

  var maxN = parseInt(document.querySelector("#nmax").value);
  var initN = parseInt(document.querySelector("#n").value);
  var count = 0;
  function recursiveFunc (n) {
    for(var i = 0; i < 8; i++) {
      if (n < maxN) {
        recursiveFunc (n + 1);
      } else {
        for(var j = 0; j < 8; j++) {
          count++;
        }
      }
    }
  }
  recursiveFunc(initN);
  document.querySelector("#expectedValue").innerHTML = 64 * (Math.pow(8, maxN - initN));// 64 * (8^(maxN - initN));
  document.querySelector("#realValue").innerHTML = count;
}

＆＃13;

N: <input type=number id=n value=0><br>
NMAX: <input type=number id=nmax value=5><br>
<hr>
Expected value: <span id=expectedValue></span><br>
Real value: <span id=realValue></span><br>
<button onclick="test()">Test</button>

＆＃13;

（我还假设initN＆lt; = maxN）

递归函数的大O表示法称为for循环

1 个答案: