Algorithm 计算递归算法的复杂度 func3（int n）{ 对于（int i=1；i

而言，

n

的位模式非常有助于说明这个问题

---

n

除以2的整数等于将位模式右移一位，丢弃最小有效大（LSB）。例如：

当每次调用

func3

时总是调用一次

func3（n-1）

时，最坏的情况是什么？

n/2

的结果必须总是奇数，因此：

所有

n

的有效位必须为1。

这对应于

n

等于二减一的幂，例如

3,7,15,31,63，

在这种情况下，对

func3（n-1）

的调用不会产生对同一函数的另一个调用，因为如果

n

为奇数，则

n-1

必须为偶数。此外，

n/2=（n-1）/2

（用于整数除法）。因此，递归关系为：

---

人们可以通过主定理得到这些结果。

n的位模式非常有助于说明这个问题

---

n

除以2的整数等于将位模式右移一位，丢弃最小有效大（LSB）。例如：

当每次调用

func3

时总是调用一次

func3（n-1）

时，最坏的情况是什么？

n/2

的结果必须总是奇数，因此：

所有

n

的有效位必须为1。

这对应于

n

等于二减一的幂，例如

3,7,15,31,63，

在这种情况下，对

func3（n-1）

的调用不会产生对同一函数的另一个调用，因为如果

n

为奇数，则

n-1

必须为偶数。此外，

n/2=（n-1）/2

（用于整数除法）。因此，递归关系为：

---

你可以通过主定理得到这些结果。

展示你自己的尝试。展示你自己的尝试。谢谢你的精彩解释，我只是不明白2*T（n/2）是从哪里来的。尤其是2@DavidZaltsman其中一个

T（n/2）

来自递归调用

f（n/2）

在倒数第二行。请注意，因为

n

是奇数，所以前面一行还有一个递归调用

f（n-1）

。从前面一行将调用

f（（n-1）/2）

，正如meowgoestedog（很好的解释）所解释的，

n

是奇数，

n/2=（n-1）/2

；因此您总共有两个调用

f（n/2）

。请注意，当您在递归调用

f（n-1）

中时，

n-1

甚至不会被调用

f（n-2）

。首先，解释很好！其次，我对复杂性有一个问题。我可以理解2*t（n/2）+o（n）的位置来自，但我不明白为什么递归调用f（n-1）没有复杂度的影响。就像所有重要的是调用f（n/2）的次数。每次调用func时，都有o（n）“功”，所以为什么f（n-1）什么都不是？提前感谢：）@davidzaltsman它没有“影响”-它是产生2T（n/2）中的“2”。请仔细阅读这篇文章，它会变得明显。谢谢你的精彩解释，我只是不明白2*T（n/2）是从哪里来的。尤其是2@DavidZaltsman其中一个

T（n/2）

来自递归调用

f（n/2）

在倒数第二行。请注意，因为

n

是奇数，所以前面一行还有一个递归调用

f（n-1）

。从前面一行将调用

f（（n-1）/2）

，正如meowgoestedog（很好的解释）所解释的，

n

是奇数，

n/2=（n-1）/2

；因此您总共有两个调用

f（n/2）

。请注意，当您在递归调用

f（n-1）

中时，

n-1

甚至不会被调用

f（n-2）

。首先，解释很好！其次，我对复杂性有一个问题。我可以理解2*t（n/2）+o（n）的位置来自，但我不明白为什么递归调用f（n-1）没有复杂度的影响。就像所有重要的是调用f（n/2）的次数。每次调用func时，都有o（n）“功”，所以为什么f（n-1）什么都不是？提前感谢：）@davidzaltsman它没有“影响”-它是产生2英寸2吨（n/2）。请仔细阅读文章，它会变得明显。

func3(int n) {
    for (int i = 1; i<n; i++)
        System.out.println("*");
    if (n <= 1)
    {
        System.out.println("*");
        return;
    }
    if(n % 2 != 0) //check if odd
        func3(n - 1)
    func3(n / 2);
    return;
}

                          binary
                       ----------------------
n = 15                 |  0000 1111 
n / 2 = 7 (round down) |  0000 0111 (1) <- discard

T(n) = T(n/2) + O(n) = O(n)

T(n) = 2 * T(n/2) + O(n) = O(n log n)