紧凑、可读、高效的C++；在位反转字符串中的单词的算法 我试图想出一个很好的C++解决方案，提示

“反转字符串中的单词（单词由一个或多个字符分隔 空格）。现在在适当的位置执行。到目前为止，最流行的字符串问题！”

我现在看到的是一个怪物：

void reverse_words ( std::string & S )
{
/* 
    Programming interview question: "Reverse words in a string (words are separated by one or more spaces). Now do it in-place. By far the most popular string question!"
    http://maxnoy.com/interviews.html 
*/
    if (S.empty()) return;
    std::string::iterator ita = S.begin() , itb = S.end() - 1;
    while (ita != itb) 
    {
      if (*ita != ' ')
      {
         std::string sa; // string to hold the current leftmost sequence of non-whitespace characters
         std::string::iterator tempa = ita; // iterator to the beginning of sa within S
         while (ita != ' ' && ita != itb) sa.push_back(*ita++); // fill sa
         while (*itb == ' ' && itb != ita) --itb; // move itb back to the first non-whitespace character preceding it
         std::string sb; // string to hold the current rightmost sequence of non-whitespace characters
         std::string::iterator tempb = itb; // iterator to the end of sb within S
         while (*itb != ' ' && itb != ita) sb.push_back(*itb--); // fill sb
         S.replace(tempa, ita-tempa, sb); // replace the current leftmost string with the current rightmost one
         S.replace(tempb, itb-tempb, sa); // and vice-versa
       }
      else
      {
         ++ita; 
      }
    }   
}

---

我认为我的想法是正确的（找到第一个字符串，用最后一个字符串交换，找到第一个字符串之后的下一个字符串，用最后一个字符串之前的字符串交换，等等），但我需要一些更好的工具来实现这一点。如何利用标准库来解决此问题？

如果使用以下方法，这非常简单：

把整根绳子倒过来

把每个单词分别倒过来

这个算法已经是O（n），您只需在整个字符串中运行一次，然后再运行一次，就可以找到每个单词的倒数

---

现在，为了使这更有效，我们来看一下反转序列的算法，它从前面和后面读取一个序列，并将每个序列存储在另一个序列的位置。现在，当你存储一个空格时，你只是终止了一个单词，所以现在就反转这个单词。效率更高的原因是，包含该字的缓存在CPU上仍然是热的。这里的困难是在极端情况下正确处理这个问题。你必须考虑中间字，字符串两端的多个连续的空格和空间。

< P>这是非常简单的，如果你使用下面的方法：

把整根绳子倒过来

把每个单词分别倒过来

这个算法已经是O（n），您只需在整个字符串中运行一次，然后再运行一次，就可以找到每个单词的倒数

---

现在，为了使这更有效，我们来看一下反转序列的算法，它从前面和后面读取一个序列，并将每个序列存储在另一个序列的位置。现在，当你存储一个空格时，你只是终止了一个单词，所以现在就反转这个单词。效率更高的原因是，包含该字的缓存在CPU上仍然是热的。这里的困难是在极端情况下正确处理这个问题。你必须考虑中间字，字符串两端的多个连续的空格和空间。

< P>这是非常简单的，如果你使用下面的方法：

把整根绳子倒过来

把每个单词分别倒过来

这个算法已经是O（n），您只需在整个字符串中运行一次，然后再运行一次，就可以找到每个单词的倒数

---

现在，为了使这更有效，我们来看一下反转序列的算法，它从前面和后面读取一个序列，并将每个序列存储在另一个序列的位置。现在，当你存储一个空格时，你只是终止了一个单词，所以现在就反转这个单词。效率更高的原因是，包含该字的缓存在CPU上仍然是热的。这里的困难是在极端情况下正确处理这个问题。你必须考虑中间字，字符串两端的多个连续的空格和空间。

< P>这是非常简单的，如果你使用下面的方法：

把整根绳子倒过来

把每个单词分别倒过来

这个算法已经是O（n），您只需在整个字符串中运行一次，然后再运行一次，就可以找到每个单词的倒数

---

现在，为了使这更有效，我们来看一下反转序列的算法，它从前面和后面读取一个序列，并将每个序列存储在另一个序列的位置。现在，当你存储一个空格时，你只是终止了一个单词，所以现在就反转这个单词。效率更高的原因是，包含该字的缓存在CPU上仍然是热的。这里的困难是在极端情况下正确处理这个问题。你必须考虑中间字，在字符串的两端都有多个连续的空格和空格。

< p>我猜是这样。简单、高效、清晰。请注意，当

pos>=str.size（）时，
std:：basic\u string:：find…
返回
npos

我想就是这个了。简单、高效、清晰。请注意，当
pos>=str.size（）时，
std:：basic\u string:：find…
返回
npos

我想就是这个了。简单、高效、清晰。请注意，当
pos>=str.size（）时，
std:：basic\u string:：find…
返回
npos

我想就是这个了。简单、高效、清晰。请注意，当
pos>=str.size（）时，
std:：basic\u string:：find…
返回
npos

“紧凑、可读、高效”-艰难的目标。通常的方法是颠倒整个字符串。然后倒转每个单词。目前，你的算法没有达到“紧凑、可读、高效”的目标。通常的方法是倒转整个字符串。然后倒转每个单词。目前，你的算法没有达到“紧凑、可读、高效”的目标。通常的方法是倒转整个字符串。然后倒转每个单词。目前，你的算法没有达到“紧凑、可读、高效”的目标。通常的方法是倒转整个字符串。然后将每个单词倒转过来。就目前情况而言，您的算法不正确
void ReverseWords(std::string& msg) {
    std::string::size_type pos_a = 0, pos_b = -1;
    while ((pos_a = msg.find_first_not_of(' ', pos_b + 1)) != msg.npos) {
        pos_b = std::min(msg.find(' ', pos_a + 1), msg.size());
        std::reverse(msg.begin() + pos_a, msg.begin() + pos_b);
    }
    std::reverse(msg.begin(), msg.end());
}