这个算法的时间复杂度是多少答案

【问题标题】：What is the time complexity of this algorithm这个算法的时间复杂度是多少
【发布时间】：2016-08-15 03:05:03
【问题描述】：

编写一个程序，该程序接受一个整数并打印出所有乘以等于原始数字的较小整数的方法，而无需重复因子集。换句话说，如果您的输出包含 4 * 3，则不应再次打印 3 * 4，因为这将是一个重复集。请注意，这不仅要求质数分解。此外，您可以假设输入整数的大小是合理的；正确性比效率更重要。打印因子(12) 12 * 1 6 * 2 4 * 3 3 * 2 * 2

public void printFactors(int number) {
    printFactors("", number, number);
}

public void printFactors(String expression, int dividend, int previous) {
    if(expression == "")
        System.out.println(previous + " * 1");

    for (int factor = dividend - 1; factor >= 2; --factor) {
        if (dividend % factor == 0 && factor <= previous) {
            int next = dividend / factor;
            if (next <= factor)
                if (next <= previous)
                    System.out.println(expression + factor + " * " + next);

            printFactors(expression + factor + " * ", next, factor);
        }
    }
}

我觉得是

如果给定的数是N，并且N的素数个数=d，那么时间复杂度是O(N^d)。这是因为递归深度将上升到素因子的数量。但它并不紧密。有什么建议吗？

【问题讨论】：

我认为代码不起作用。例如：nextnext 未定义。
@PaulHankin。抱歉，这是一个错字。修复它
重复stackoverflow.com/questions/38949619/…
("* 1-product" 可以放在不需要控制的单参数方法中。将表达式转换为StringBuilder 会妨碍可读性并且没有真正帮助： “每个”字符串被打印。如果factor <= previous，next <= factor 暗示next <= previous。出于原则，我会初始化factor = Math.min(dividend/2, previous)。）

标签： algorithm time-complexity number-theory

【解决方案1】：

2 个想法：

算法是输出敏感的。输出一个因式分解最多使用循环的 O(N) 次迭代，所以总的来说我们有 O(N * number_of_factorizations)

另外，根据马斯特定理，等式是：F(N) = d * F(N/2) + O(N)，所以总的来说我们有O(N^log_2(d))

【讨论】：

为什么是 d*F(N/2)，是因为在最坏的情况下，一个因子可以将原始数字分成两半，并且有 d 个素因子。同样根据主定理 d 不能大于 2。O(N) 来自哪里？是不是因为在最坏的情况下它可能是 N 个数的倍数？
@user12331 您对 d*F(N/2) 的原因是正确的。 Case 1 example 说 a 可以是 8，所以说它不能超过 2 是不正确的。O(N) 是因为 for 循环迭代了 N 次左右。
顺便说一句，第一个界限更严格，因为分解的数量不会比 O(N) 增长得快（证明？），所以总的来说它并不比 O(N^2) 差。另外，我觉得最坏的情况确实是 O(N log N)，但现在无法证明。

【解决方案2】：

时间复杂度应该是：

number of iterations * number of sub calls ^ depth

有 O(log N) 个子调用而不是 O(N)，因为 the number of divisors of N is O(log N)

递归的深度也是O(log N)，每次递归调用的迭代次数小于N/(2^depth)，所以整体时间复杂度是O(N((log N)/2) ^(log N))

【讨论】：

【解决方案3】：

The time complexity is calculated as : Total number of iterations multiplied 
by no of sub iterations^depth.So over all complexity id Y(n)=O(no of
dividends)*O(number of factorization )+O(no of (factors-2) in loop);

Example PrintFactors(12) 12 * 1 ,6 * 2, 4 * 3, 3 * 2 * 2
O(no of dividends)=12
O(number of factorization)=3
O(no of factors-2){ in case of 3 * 2 * 2)=1 extra

Over all: O(N^logbase2(dividends))

【讨论】：