为什么这个阶乘查找算法的运行时复杂度不是 O(n!)？

Question

I discovered this issue by implemented the algorithm from this post: Example of O(n!)?

I tried counting the operations though, and the algorithm loops 64 times when calculating 4! (which is 24).

Is there something I'm missing? Or does this algorithm really just have a run-time complexity that is not O(n!)

 var operations = 0; function factorial(n) { for (let i = 0; i < n; i++) { operations++; factorial(n - 1); } } console.log(factorial(4)) console.log('operations: ', operations) // prints 64 operations

Answer 1

There is probably a good theoretical analysis, but here is an empirical one. I ran the program for numbers 0 to 12 and tracked operations. Notice that very quickly the operations tend to be really close to n times the previous entry. And the ratio of operations to n! appears to tend to e. Thus, if the limit of operations is e (or some constant) times n!, we are O(n!). We need not = n! to make that so.

Answer 2

You're counting loop operations on every recursion level (ie counting function calls except for the outermost one), instead of counting the innermost function calls. Therefore you're getting a much higher count than the plain factorial you were expecting:

1                         = 1
2 + 2*1                   = 4
3 + 3*2 + 3*2*1           = 15
4 + 4*3 + 4*3*2 + 4*3*2*1 = 64
…

The expansions for arbitrary n can be found in https://oeis.org/A007526 . These are still limited by O(n!) though - see the closed formulas in the link, eg floor(e*n! - 1) or n! * Sum_{k=0..n-1} 1/k! n! * Sum_{k=0..n-1} 1/k! , which are clearly dominated by the n! term. (Counting all invocations gives you https://oeis.org/A000522 , n! * Sum_{k=0..n} 1/k! ).

To get exactly a factorial, you'd need to count only the innermost function calls:

 var operations = 0; function factorial(n) { if (n == 0) operations++; for (let i = 0; i < n; i++) { factorial(n - 1); } } console.log(factorial(4)) console.log('operations: ', operations) // prints 64 operations

Answer 3

The factorial function should be:

var operations = 0;

function factorial(n) {
    operation++;
    if (n === 0) return 1;
    return n*factorial(n - 1);
}

console.log(factorial(4))
console.log('operations: ', operations) // prints 24 operations

And it's O(n). The example is about O(n!), which is a time complexity depend on n!, not n! itself.