151. 反转字符串中的单词（力扣LeetCode）

151. 反转字符串中的单词

题目描述

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = “the sky is blue”
输出：“blue is sky the”

示例 2：

输入：s = " hello world "
输出：“world hello”
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = “a good example”
输出：“example good a”
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

提示：

• 1 <= s.length <= 10⁴
• s 包含英文大小写字母、数字和空格 ’ ’
• s 中 至少存在一个 单词

进阶：如果字符串在你使用的编程语言中是一种可变数据类型，请尝试使用 O(1) 额外空间复杂度的 原地 解法。

双指针

思路

想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。

所以解题思路如下：

移除多余空格
将整个字符串反转
将每个单词反转
举个例子，源字符串为："the sky is blue "

移除多余空格 : “the sky is blue”
字符串反转：“eulb si yks eht”
单词反转：“blue is sky the”
这样我们就完成了翻转字符串里的单词。

思路很明确了，我们说一说代码的实现细节，就拿移除多余空格来说，一些同学会上来写如下代码：

void removeExtraSpaces(string& s) {
    for (int i = s.size() - 1; i > 0; i--) {
        if (s[i] == s[i - 1] && s[i] == ' ') {
            s.erase(s.begin() + i);
        }
    }
    // 删除字符串最后面的空格
    if (s.size() > 0 && s[s.size() - 1] == ' ') {
        s.erase(s.begin() + s.size() - 1);
    }
    // 删除字符串最前面的空格
    if (s.size() > 0 && s[0] == ' ') {
        s.erase(s.begin());
    }
}

逻辑很简单，从前向后遍历，遇到空格了就erase。

如果不仔细琢磨一下erase的时间复杂度，还以为以上的代码是O(n)的时间复杂度呢。

想一下真正的时间复杂度是多少，一个erase本来就是O(n)的操作。

erase操作上面还套了一个for循环，那么以上代码移除冗余空格的代码时间复杂度为O(n^2)。

那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。

//版本一 
void removeExtraSpaces(string& s) {
    int slowIndex = 0, fastIndex = 0; // 定义快指针，慢指针
    // 去掉字符串前面的空格
    while (s.size() > 0 && fastIndex < s.size() && s[fastIndex] == ' ') {
        fastIndex++;
    }
    for (; fastIndex < s.size(); fastIndex++) {
        // 去掉字符串中间部分的冗余空格
        if (fastIndex - 1 > 0
                && s[fastIndex - 1] == s[fastIndex]
                && s[fastIndex] == ' ') {
            continue;
        } else {
            s[slowIndex++] = s[fastIndex];
        }
    }
    if (slowIndex - 1 > 0 && s[slowIndex - 1] == ' ') { // 去掉字符串末尾的空格
        s.resize(slowIndex - 1);
    } else {
        s.resize(slowIndex); // 重新设置字符串大小
    }
}

有的同学可能发现用erase来移除空格，在leetcode上性能也还行。主要是以下几点；：

leetcode上的测试集里，字符串的长度不够长，如果足够长，性能差距会非常明显。
leetcode的测程序耗时不是很准确的。
版本一的代码是一般的思考过程，就是 先移除字符串前的空格，再移除中间的，再移除后面部分。

不过其实还可以优化，这部分和27.移除元素 的逻辑是一样一样的，本题是移除空格，而 27.移除元素 就是移除元素。

所以代码可以写的很精简，大家可以看 如下 代码 removeExtraSpaces 函数的实现：

// 版本二 
void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
    int slow = 0;   //整体思想参考https://programmercarl.com/0027.移除元素.html
    for (int i = 0; i < s.size(); ++i) { //
        if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
            if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
            while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                s[slow++] = s[i++];
            }
        }
    }
    s.resize(slow); //slow的大小即为去除多余空格后的大小。
}

此时我们已经实现了removeExtraSpaces函数来移除冗余空格。

还要实现反转字符串的功能，支持反转字符串子区间，这个实现我们分别在344.反转字符串 和541.反转字符串II 里已经讲过了。

代码如下：

// 反转字符串s中左闭右闭的区间[start, end]
void reverse(string& s, int start, int end) {
    for (int i = start, j = end; i < j; i++, j--) {
        swap(s[i], s[j]);
    }
}

代码

版本二（精简版）

整个函数流程如下：

1. 首先反转整个字符串：这样做是为了让单词的顺序颠倒，但此时单词本身也被反转了。

2. 然后移除多余空格：通过快慢指针技巧，快指针用于找到单词的起始和终止位置，慢指针用于构建一个没有多余空格的新字符串。

3. 最后再次反转每个单词：由于第一步中单词被反转过来，为了恢复单词原来的顺序，需要再次反转每个单词。

4. 调整字符串尺寸并返回结果：最终的字符串是没有多余空格的，并且单词顺序与原字符串相反。

这个函数没有使用额外的存储空间（原地操作），并且通过两次遍历（每次O(n)时间复杂度）完成了题目要求的操作。

class Solution {
public:
    // reverseWords函数接收一个字符串s，返回单词顺序颠倒的字符串。
    string reverseWords(string s) {
        
        // 首先反转整个字符串。
        reverse(s.begin(), s.end());

        int slow = 0; // 定义一个慢指针，用于重构字符串。

        // 使用快指针遍历字符串每个字符。
        for (int fast = 0; fast < s.size(); fast++) {
            if (s[fast] != ' ') { // 如果当前字符不是空格，表示单词的开始。
                if (slow != 0) // 如果不是第一个单词，在单词前添加空格。
                    s[slow++] = ' ';

                // 将整个单词复制到慢指针指向的位置。
                while (fast < s.size() && s[fast] != ' ') 
                    s[slow++] = s[fast++];
            }
        }
        // 调整字符串s的大小，去掉末尾多余的空格。
        s.resize(slow);

        int start = 0; // 单词的起始位置。
        // 再次遍历字符串，这次是为了反转每个单词。
        for (int i = 0; i <= s.size(); i++) {
            if (i == s.size() || s[i] == ' ') { // 如果当前字符是字符串尾部或空格，表示单词的结束。
                // 反转从start到当前位置i的单词。
                reverse(s.begin() + start, s.begin() + i);
                start = i + 1; // 更新下一个单词的起始位置。
            }
        }

        // 返回处理后的字符串。
        return s;
    }
};

版本一

函数流程如下：

1. 首先反转整个字符串：这样单词的顺序被颠倒，但这些单词本身也被反转了，且可能有多余空格。

2. 移除前导空格和多余空格：快指针 fast 用于跳过前导空格和连续的空格，而慢指针 slow 用于构建没有多余空格的新字符串。

3. 移除尾部多余的空格：通过检查 slow 指针的前一个位置是否为空格来调整字符串大小。

4. 反转每个单词：最后再次遍历字符串，当遇到空格或字符串结尾时，反转单词。

5. 返回最终字符串：最终的字符串没有多余的空格，并且单词顺序与输入字符串相反。

这个函数实现了题目要求的功能，使用了原地操作（没有使用额外的存储空间），然后完成单词的反转，并且在单词之间只保留一个空格。

class Solution {
public:
    // reverseWords函数接收一个字符串s并返回单词顺序反转后的字符串
    string reverseWords(string s) {
        
        // 首先反转整个字符串。
        reverse(s.begin(), s.end());

        int fast = 0, slow = 0; // 定义快慢指针。

        // 移动快指针跳过前导空格。
        while (fast < s.size() && s[fast] == ' ') fast++;

        // 遍历字符串，快指针用于跳过连续的空格。
        for (; fast < s.size(); fast++) {
            if (fast - 1 >= 0 && s[fast] == s[fast - 1] && s[fast] == ' ') 
                continue; // 如果当前字符是空格且与前一个字符相同，则跳过。
            else
                s[slow++] = s[fast]; // 否则，将快指针指向的字符复制到慢指针位置，并移动慢指针。
        }

        // 移除尾部多余的空格。如果慢指针的前一个字符是空格，则调整大小为slow-1，否则为slow。
        if (slow - 1 >= 0 && s[slow - 1] == ' ')
            s.resize(slow - 1);
        else
            s.resize(slow);

        // 初始化单词的起始位置。
        int start = 0;
        // 再次遍历字符串，反转每个单词。
        for (int i = 0; i <= s.size(); i++) {
            // 如果当前位置是字符串的尾部或者遇到空格，表示一个单词的结束。
            if (i == s.size() || s[i] == ' ') {
                // 反转从start到当前位置i的单词。
                reverse(s.begin() + start, s.begin() + i);
                start = i + 1; // 更新下一个单词的起始位置。
            }
        }

        // 返回处理后的字符串。
        return s;
    }
};