代码随想录训练营打卡第九天

最新推荐文章于 2024-10-03 00:32:59 发布

UtsumiEr1c3

最新推荐文章于 2024-10-03 00:32:59 发布

阅读量298

点赞数 4

文章标签： c++ 算法

本文链接：https://blog.csdn.net/yhxzcsq/article/details/141533947

版权

代码随想录: 代码随想录

151. 反转字符串中的单词

class Solution {
public:
    void removeExtraSpaces(string& s) {
        int slow = 0, fast = 0;
        for (; fast < s.size(); fast++) {
            if (s[fast] != ' ') {
                if (slow != 0) {
                    s[slow] = ' ';
                    slow++;
                }
                while (fast < s.size() && s[fast] != ' ') {
                    s[slow] = s[fast];
                    slow++;
                    fast++;
                }
            }
        }
        s.resize(slow);
    }
    string reverseWords(string s) {
        reverse(s.begin(), s.end());
        removeExtraSpaces(s);
        int slow = 0, fast = 0;
        for ( ; fast <= s.size(); fast++) {
            if (fast == s.size() || s[fast] == ' ') {
                reverse(s.begin() + slow, s.begin() + fast);
                slow = fast + 1;
            }
        }
        return s;
    }
};

右旋字符串

链接: 55. 右旋字符串（第八期模拟笔试）

#include <iostream>
using namespace std;

int main()
{
    int n; string s;
    cin >> n >> s;
    string ans;
    for (int i = s.size() - n; i < s.size(); i++) {
        ans += s[i];
    }
    for (int i = 0; i < s.size() - n; i++) {
        ans += s[i];
    }
    cout << ans;
    
    return 0;
}

O(n)空间

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    int n; string s;
    cin >> n >> s;
    int len = s.size(); //获取长度

    reverse(s.begin(), s.end()); // 整体反转
    reverse(s.begin(), s.begin() + n); // 先反转前一段，长度n
    reverse(s.begin() + n, s.end()); // 再反转后一段
    
    cout << s;
    return 0;
}

O(1)空间

但两种方法在判题机上消耗的内存均为2180kb, 以下是Claude sonnet 3.5的解释:

您提出了一个非常好的问题。确实，从理论上讲，第二种方法的空间复杂度是 O(n)，而第一种是 O(1)。让我们深入分析为什么实际测试中它们可能显示相同的内存消耗：

字符串的实现： C++ 的 std::string 通常使用小字符串优化（SSO）。对于小字符串（通常小于 15 或 23 字符，取决于实现），数据直接存储在 string 对象内部，而不是在堆上分配额外内存。如果输入的字符串足够小，两种方法可能都不会触发堆分配。
内存分配的粒度：即使第二种方法确实在堆上分配了额外内存，操作系统的内存分配通常以较大的块（如 4KB）进行。所以即使多分配了一个字符串的空间，可能也不会导致额外的内存页被分配。
程序的基本开销：两个程序的大部分内存使用可能来自于共同的基本结构（如可执行文件本身、加载的库、栈空间等）。相比之下，一个额外的字符串可能只是很小的增量。
内存计算和报告方式：
- 判题系统可能只报告峰值内存使用，而不是整个执行过程中的累积使用。
- 内存使用可能被四舍五入到最近的 KB，掩盖了小的差异。
编译器优化：现代编译器可能会优化掉看似多余的内存分配，特别是在小规模数据上。
测试数据规模：如果测试用的字符串不够长，可能无法显示出两种方法在空间使用上的理论差异。
栈 vs 堆：第二种方法创建的新字符串可能被编译器优化为栈上分配，而不是堆上，这样就不会增加程序的整体内存占用。

要真正看到这两种方法在内存使用上的差异，您可能需要：