执行字符串连接时的性能 - 算法字符串字符串 c#

Question

我使用下面的代码来附加字符串

string res = string.Empty;
int ite = 100000;
for(int i= 0; i < ite; i++)
{
    res += "5";
}

花了很多时间，所以我后来把代码改成了

string res = string.Empty;
int ite = 100000;
res = getStr(ite / 2) + getStr(ite - (ite / 2)); 

//body of getStr method
private static string getStr(int p)
{
    if (p == 1)
        return "5";
    else if (p == 0)
        return string.Empty;
    string r1 = getStr(p / 2); //recursive
    string r2 = getStr(p - (p / 2)); //recursive  
    return (r1 + r2);
}

在我看来实际上什么也没做，因为字符串连接的次数与以前的方法大致相同。

但是使用这种方法可以显着提高性能，因为（在我的机器上）大约需要 2500 毫秒的代码现在需要 10 毫秒。

我在 cpu 时间内运行了一个分析器，但无法理解为什么性能会有所提高。谁能解释一下。

注意：我故意不使用StringBuilder，为了理解上面的内容。

Answer 1

您需要考虑为什么字符串连接很慢。字符串是不可变的，所以当你这样做时：

someString+= "5";

您必须将someString 的全部内容 复制到另一个更大的字符串，然后复制到5 部分。如果您考虑一下，字符串越长，它就会变得越来越慢。

使用您的递归函数，您正在执行分而治之的策略，以帮助最大限度地减少您需要的大字符串连接的数量。例如，如果您的长度为 8，则在第一种情况下，您会这样做：

"5" + "5" 
"55" + "5"
"555" + "5"
"5555" + "5"
"55555" + "5"
"555555" + "5"
"5555555" + "5"    // 7 total concatenations

在你正在做的递归模型中：

"5" + "5"         // Four times
"55" + "55"       // twice
"5555" + "5555"   // once 

所以你正在做更少的大连接。

当然，我认为 OP 从他们的评论中知道这一点，但对于其他任何人；如果您需要连接任何重要数量的字符串，请使用StringBuilder，因为它针对构建字符串进行了优化，Append将它们组合在一起。

Answer 2

假设 - 根据 Matt Burland 的回答 - 通过给定算法之一创建长度为 n 的字符串的时间成本是 以复制的字符数为主， 观察到的时间可以通过计算这两种算法来很大程度上解释。 这产生 O(n²) 和 O(n log n) 并且对于长度为 10,000 的比率348:1。该算法在 Java 中可能会改进为 O(n)，但在 .NET 中显然不会。

改进算法的成本

对改进算法的检验表明，复制的字符数c(n)服从如下递推关系：

c(0) = 0
c(1) = 1
c(n em>) = c(⌊n/2⌋) + c(⌈n/2⌉) + n

这个问题可以解决

c(2^k + a) = (k + 1 )2^k + (k + 3)a

选择 k 和 a 以使 n = 2^k + a , a k ;这很容易通过完全归纳来验证。 这是O(k 2^k)，即O(n log₂n), 即 O(n log n),

说明：成本比较

原算法清晰地复制了n(n+1)/2个字符，因此为O(n^2)。

修改后的算法明显减少了复制的字符； 对于给定的 10,000 个字符串：

c(10000) =
c(2¹³ + 1808) =
(13+1) * 8192 + 16 * 1808 =
143,616

原始算法复制 50,005,000 个字符，比例约为 1 : 348， 与观察到的 1:250 的比率在一个数量级内完全一致。 不完美的匹配确实表明内存管理等其他因素可能很重要。

进一步优化

假设字符串是用单个字符填充的， 假设 String.Substring 不会复制字符串， 根据comparison-of-substring-operation-performance-between-net-and-java，这在 Java 中是正确的，但 不是 .NET ， 我们可以改进第二种算法（不使用StringBuilder 或String('5', ite)） 通过不断加倍构造的字符串，必要时添加一个额外的字符：

private static string getStr(int p)
{
    if(p == 0)
        return "";
    if(p == 1)
        return "5";
    string s = getStr ((p+1) / 2);
    if( s.Length + s.Length == p )
        return s + s;
    else
        return s + s.Substring(0, p - s.Length);
}

对于这个算法复制的字符数c₂(n)，我们有

c₂(n) = n + c ₂(⌈n/2⌉)

我们可以从中得到

c₂(n) = 2_n_ + d(n)

如果 n 是 2 的幂，则 d(n) 为 -1，否则为“内部”（即既不是前导也不是尾随）位数相等在 m 的二进制展开中为 0； 等效地，d(n) 由 m ∈ ℕ in:

的第一个匹配案例定义

d(2^m) = -1
d(2 m) = d(m)
d(m) = 基本数（非前导）m

中的 0 个二进制数字

c₂ 的表达式也可以通过完全归纳来验证，并且是 O(n + log n)，即 O(n)。

从这个算法中移除递归是相当简单的。

在 OP 的情况下，此算法复制 c₂(10,000) = 20,000 + d(11000011010100000₂) = 20,006 个字符 因此看起来会快 7 倍。

其他说明

• 此分析适用于创建任意字符串的倍数，而不仅仅是"5"。
• 构造 OP 字符串的最有效方式大概是String('5', ite)。
• 如果使用StringBuilder 构建已知大小的字符串，可以使用StringBuilder(capacity) 来减少分配。
• 此分析适用于 .NET 以外的其他环境。
• 在 C 中，分配一个大小合适的缓冲区（包括 '\0'!），复制要重复的字符串，然后重复附加缓冲区已填充部分的副本，直到填满为止。