两种递归方法的Java复杂度

Question

public static String rec1 (String s) {

    int n = s.length()/2; 
    return n==0 ? s : rec1(s.substring(n)) + rec1(s.substring(0,n)); 
}


public static String rec2 (String s) {
    return s.length()<=1 ? s : rec2(s.substring(1)) + s.charAt(0); 
}

为什么rec2 的复杂度大于rec1？

我对每个都进行了 10.000 次迭代，并使用 System.nanoTime() 测量了执行时间，结果如下：

rec1：字符串长度：200 平均时间：19912ns 递归调用：399 rec1：字符串长度：400 平均时间：42294 ns 递归调用：799 rec1：字符串长度：800 平均时间：77674 ns 递归调用：1599 rec1：字符串长度：1600 平均时间：146305 ns 递归调用：3199 rec2：字符串长度：200 平均时间：26386 ns 递归调用：200 rec2：字符串长度：400 平均时间：100677 ns 递归调用：400 rec2：字符串长度：800 平均时间：394448 ns 递归调用：800 rec2：字符串长度：1600 平均时间：1505853 ns 递归调用：1600

所以在字符串长度为 1600 时，rec1 比 rec2 快 10 倍。我正在寻找一个简短的解释。

Answer 1

根据Time complexity of Java's substring()，String#substring 现在复制后备数组，O(n) 时间复杂度也是如此。

利用这一事实可以看出rec1 的时间复杂度为O(n log n)，而rec2 的时间复杂度为O(n^2)。

以初始 String s = "12345678" 开头。为简单起见，我将长度取为 2 的幂。

rec1:

1. s 分为"1234" 和"5678"。
2. 这些分为"12"、"34"、"56"、"78"
3. 这些被分成"1"、"2"、"3"、"4"、"5"、"6"、"7"、"8"

这里有 3 个步骤，因为log(8) = 3。每个char在每一步都被复制，所以复制的字符总数为O(n log n)。当String 以相反的顺序重新组装时，上面的Strings 现在使用串联连接在一起，使用以下步骤：

1. 字符串加入"21"、"43"、"65"、"87"
2. 字符串加入"4321"、"8765"
3. 字符串被连接成"87654321"。

这又是O(n log n)复制的字符！

rec2:

1. s 分为"1" 和"2345678"。
2. "2345678" 分为"2" 和"345678"。
3. "345678" 分为"3" 和"45678"。
4. "45678" 分为"4" 和"5678"。
5. "5678" 分为"5" 和"678"。
6. "678" 分为"6" 和"78"。
7. "78" 分为"7" 和"8"。

这是总共8 + 7 + 6 + 5 + 4 + 3 + 2 = 35 个复制字符。如果你知道代数，这通常是(n * (n+1)) / 2 - 1复制的字符，所以O(n^2)。

当这一切以相反的顺序组装时，副本字符数将再次为O(n^2)。

Answer 2

让我们研究一下性能差异：

String.substring() 

• substring 在 Java 中非常便宜（直到 Java 7 Update 6），因为它不会复制原始数据，而只会更新同一数组上的偏移量。

字符串覆盖 + 运算符

• 这里出现了差异，因为覆盖+ 运算符在非文字字符串的情况下使用StringBuilder。如果您深入了解StringBuilder.append() 方法的实现，您最终会找到对System.arraycopy() 的调用。

所以区别在于System.arraycopy() 处理的是rec1 中呈指数减小的数组大小，而rec2 中只处理线性减小的数组大小。

Answer 3

（这是关于时间复杂度的修正版本）

虽然递归的次数实际上在 n 中是线性的（因为递归在每一级都被调用两次），但就复制字符而言，两种方法之间存在差异。

每个方法在内部执行两个复制操作 - 一个用于 substring（在 Java 7 中），一个用于 concat（由 + 运算符表示）。

在rec2 中，它会一遍又一遍地复制字符串的右侧，直到只剩下一个字符。所以字符串中的最后一个字符被复制depth次，深度是线性的。所以线性步骤乘以线性副本（实际上是一个系列）得到 O(n²)。

在rec1 中，每个字符要么复制到左子字符串，要么复制到右子字符串。但是没有字符被复制超过 depth 次 - 直到我们得到单字符子字符串。所以每个字符都被复制了 n 次。递归虽然调用了两次，但并不是对同一个字符调用，所以两次调用引起的日志取消不会影响每个字符的副本数。

重建也是如此。相同的副本反过来发生。

副本数 - n 个字符乘以 log n 的 深度，得到 O(n log n)。执行的步骤数 - O(n)，因此步骤数不如副本数重要，总复杂度为 O(n log n)。

---

此外，还有空间复杂度。 rec1 递归的深度为 O(log n)，也就是说，它占用了 O(log n) 的堆栈空间。它这样做了两次，但这并没有改变大O。相比之下，rec2 的深度为 O(n)。

在我的机器上，使用长度为 16384 的字符串运行这两种方法会导致 rec2 的堆栈溢出。 rec1 完成没有问题。当然，这取决于您的 JVM 设置，但您了解情况。