使用速记运算符的字符串连接有区别吗?
Is there difference in string concatenation using shortand operator?
我尝试使用 + 运算符将字符附加到字符串的末尾以解决编码问题。该解决方案超出了内存限制。然后我看到了使用 += 附加字符的解决方案。两者在时间复杂度或内存复杂度上有什么区别吗?
示例 - 我的解决方案
string arrangeWords(string text) {
text[0] = text[0] + 32;
text = text + ' ';
string temp = "";
map < int, vector < string >> mp;
for (char c: text) {
if (c != ' ')
temp = temp + c; //---Notice this line
else {
mp[temp.size()].push_back(temp);
temp = "";
}
}
string res = "";
for (auto it: mp)
for (auto j: it.second)
res = res + j + ' '; //----Notice this line
res[0] = toupper(res[0]);
return res.substr(0, res.size() - 1);
}
接受的解决方案 -
string arrangeWords(string text) {
text[0] += 32;
text += ' ';
string temp = "";
map < int, vector < string >> mp;
for (char c: text) {
if (c != ' ')
temp += c; //Notice this line change
else {
mp[temp.size()].push_back(temp);
temp = "";
}
}
string res = "";
for (auto it: mp)
for (auto j: it.second)
res += j + ' '; //Notice this line change
res[0] = toupper(res[0]);
return res.substr(0, res.size() - 1);
}
temp = temp + c;
在分配给 temp
之前创建一个临时 temp + c
(这可能需要(缓慢)分配)。 (复杂度为 O(n))
temp += c;
如果足够大就重用缓冲区(复杂度 O(1)),否则应该重新分配(然后,这将是 "similar" 到上面的方法)(复杂度 O(n) ). (摊销复杂度为 O(1)
)
此外,分配更少,内存碎片的机会更少。
我尝试使用 + 运算符将字符附加到字符串的末尾以解决编码问题。该解决方案超出了内存限制。然后我看到了使用 += 附加字符的解决方案。两者在时间复杂度或内存复杂度上有什么区别吗?
示例 - 我的解决方案
string arrangeWords(string text) {
text[0] = text[0] + 32;
text = text + ' ';
string temp = "";
map < int, vector < string >> mp;
for (char c: text) {
if (c != ' ')
temp = temp + c; //---Notice this line
else {
mp[temp.size()].push_back(temp);
temp = "";
}
}
string res = "";
for (auto it: mp)
for (auto j: it.second)
res = res + j + ' '; //----Notice this line
res[0] = toupper(res[0]);
return res.substr(0, res.size() - 1);
}
接受的解决方案 -
string arrangeWords(string text) {
text[0] += 32;
text += ' ';
string temp = "";
map < int, vector < string >> mp;
for (char c: text) {
if (c != ' ')
temp += c; //Notice this line change
else {
mp[temp.size()].push_back(temp);
temp = "";
}
}
string res = "";
for (auto it: mp)
for (auto j: it.second)
res += j + ' '; //Notice this line change
res[0] = toupper(res[0]);
return res.substr(0, res.size() - 1);
}
temp = temp + c;
在分配给 temp
之前创建一个临时 temp + c
(这可能需要(缓慢)分配)。 (复杂度为 O(n))
temp += c;
如果足够大就重用缓冲区(复杂度 O(1)),否则应该重新分配(然后,这将是 "similar" 到上面的方法)(复杂度 O(n) ). (摊销复杂度为 O(1)
)
此外,分配更少,内存碎片的机会更少。