具有两次调用的递归函数的时间复杂度

Question

考虑这段代码：

def count_7(lst):
    if len(lst) == 1:
        if lst[0] == 7:
            return 1
        else:
            return 0

    return count_7(lst[:len(lst)//2]) + count_7(lst[len(lst)//2:])

注意：切片操作将被视为 O(1)。

所以，我的推断告诉我它是 O(n*logn)，但我正在努力科学地证明它。
很高兴得到帮助！

Answer 1

好的，数学上（有点;）我得到了这样的东西：

T(n) = 2T(n/2) + c
T(1) = 1

推广方程：

T(n) = 2^k * T(n/2^k) + (2^k - 1) * c
T(1) = 1

n/2^k == 1 当k == logN 所以：

T(n) = 2^logN * T(1) + (2^logN - 1) * c

因为T(1) = 1 并应用对数属性

T(n) = n * 1 + (n-1) * c
T(n) = n + n * c
T(n) = n * (1+c)
T(n) = O(n)

这不是O(n*logn) 的一个线索是您不必将这两个子问题结合起来。与mergesort 不同，你必须合并两个子数组，这个算法不需要对递归结果做任何事情，所以它的时间可以表示为常数c。

更新：背后的直觉

这个算法应该是 O(n)，因为你只访问数组中的每个元素一次。它可能看起来并不简单，因为递归从来都不是。

例如，您将问题分成两个大小为一半的子问题，然后每个子问题也被分成一半大小，并且将继续进行，直到每个子问题的大小为 1。完成后，您将有 n 个大小为 1 的子问题，即n*O(1) = O(n)。

从第一个问题开始到 N 个大小为 1 的问题的路径是对数的，因为在每一步中你都细分为两部分。但是在每一步中，您都不会对结果做任何事情，因此这不会给解决方案增加任何时间复杂度。

希望对你有帮助

Answer 2

为简单起见，最简单的方法是假设 n 是 2 的倍数：n = 2<sup>m</sup>

你的算法的时间复杂度是（c是一个常数）：

t(n) = 2 t(n/2) + c

使用递归，你会得到：

t(n) = 2<sup>2</sup> t(n/2<sup>2</sup>) + 2c + c

     ...

     = 2<sup>log(n)</sup> t(n/2<sup>log(n)</sup>) + c(2<sup>log(n)-1</sup> + ... + 2<sup>2</sup> + 2<sup>1</sup> + 2<sup>0</sup>)

这可以通过注意到log(n) = m 和2<sup>log(n)</sup> = 2<sup>m</sup> = n 来简化。

     = n + c(2<sup>log(n)-1</sup> + ... + 2<sup>2</sup> + 2<sup>1</sup> + 2<sup>0</sup>)

最后，上面的总和可以减少到2<sup>log(n)</sup>（等于n）

 t(n) = (1 + c) n

所以你的解决方案是 O(n)

Answer 3

您扫描列表中的所有元素一次，即 O(n)。与简单递归扫描的唯一区别 是您扫描它们的顺序。你做 1, n/2, 2, 3/4n 等等...而不是 1,2,3 .... 但复杂度是一样的。