Question

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

void RevStr (char *str)
{   
    if(*str !=0)
    {
        vector<char> v1;

        while((*str != ' ')&&(*str !=0))
            v1.push_back(*str++);
        // trying to not add space in the last word of string
        if(*str !=0)
        {
            v1.push_back(' ');
            str++;
        }
        RevStr(str);
        cout<<*str;
    }


}
int main()
{
    RevStr("hello world!");
    cout<<endl;

}

我想更改字符串中单词的顺序，例如“你好吗”=＆gt; “你好吗”

我遇到了一些问题，它没有正确打印（仅打印w），请帮助我并告诉我我做错了什么。但我知道我不应该叫“cout＆lt;＆lt; * str; “因为我在堆栈中插入”char数组“（recurssion），但我不知道我需要做什么。

Answer 1

执行此操作的常用方法是首先反转整个字符串，然后对每个单词反转单词中的字母。所以不需要递归。你可能会觉得尝试一下更容易（是的，我知道这不是完全你的问题的答案:)）。

Answer 2

C ++简化了：

#include <algorithm>
#include <iterator>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>

std::string reverse(std::string const& text)
{
    std::stringstream           inStream(text);
    std::stringstream           outStream;
    std::vector<std::string>    words;

    std::copy(std::istream_iterator<std::string>(inStream), std::istream_iterator<std::string>(), std::back_inserter(words));
    std::copy(words.rbegin(), words.rend(), std::ostream_iterator<std::string>(outStream, " "));
    return outStream.str();
}


int main()
{
    std::cout << reverse("Hello World") << "\n";
}

Answer 3

使用cout << str而不是cout << *str来打印字符串。 operator<<存在char *重载。但也许这不是你想要做的;无论如何，我无法完全遵循你的逻辑。

Answer 4

你正在失去“你好”的一部分。

你似乎想要的算法是这样的：

每次调用RevStr都会将字符串中的第一个单词隔离为参数
使用剩余的字符串

RevStr

在堆栈展开时打印在步骤1中隔离的单词

基本上，您应该打印v1数据。

Answer 5

我强烈建议您使用通过std::string公开的某些功能作为开始的地方。

您可能会这样做的一种方式如下：

std::string ReverseString(std::string s)
{
    std::stack<std::string > stack;
    std::string tmpstr = "";
    std::string newstr = "";
    size_t strsize = s.size();
    size_t pos  = 0;   size_t tmppos = 0;
    size_t i = 0;      size_t stacksize = 0;
    while( pos < strsize )
    {
        tmppos = s.find(" ", pos, 1);    // starting as pos, look for " "
        if (tmppos == std::string::npos) // std::string::npos => reached end
        {
            tmppos = strsize;            // don't forget the last item.
        }     
        tmpstr = s.substr(pos, tmppos-pos); // split the string.
        stack.push(tmpstr);                 // push said string onto the stack
        pos = tmppos+1;
    }
    stacksize = stack.size();
    for ( i = 0; i < stacksize; i++ )
    {
        tmpstr = stack.top();              // grab string from top of the stack
        stack.pop();                       // stacks being LIFO, we're getting 
        if ( i != 0 )                      // everything backwards.
        {
            newstr.append(" ");            // add preceding whitespace.
        }
        newstr.append(tmpstr);             // append word.
    }
    return newstr;
}

这绝不是实现这一目标的最佳或最快方式;还有很多其他方法可以做到（例如Jerry Coffin提到使用std::vector和迭代器），但是因为你拥有C ++的强大功能，对我来说使用它是有意义的。

我已经这样做了，所以你可以使用不同的分隔符。

如果您感兴趣，现在可以将其用于：

int main(int argc, char** argv)
{
    std::string s = "In Soviet Russia String Format You";
    std::string t = ReverseString(s);
    std::cout << t << std::endl;
}

Answer 6

鉴于它是一个char *，它将其反转到位（即，不需要与传入的'str'成比例的更多内存）。这样可以避免将它转换为std :: string（这不是一个坏主意，只是因为它是一个以*开头的字符。）

void reverse_words(char* str)
{
    char* last = strlen(str) + str;
    char *s, *e;
    std::reverse(str,last);
    for(s=e=str; e != last; e++)
    {
        if(*e == ' ') 
        {
            std::reverse(s,e);
            s = e+1;
        }
    }
    std::reverse(s,e);  
}

Answer 7

void Reverse(const string& text)
{
    list<string> words;
    string temp;
    for ( auto cur = text.begin(); cur != text.end(); ++cur)
    {
        if (*cur == ' ')
        {
            words.push_front(temp);
            temp.clear();
        }
        else
        {
            temp += *cur;
        }
    }
    if (! temp.empty())
    {
        words.push_front(temp);
    }

    for_each(words.begin(), words.end(), [](const string& word) { cout << word << " "; });
    cout << endl;
}

Answer 8

void swap(char* c1, char* c2) {
    char tmp = *c1;
    *c1 = *c2;
    *c2 = tmp;
}

void reverse(char* s, char* e) {
     if (s == NULL || e == NULL)
        return;
     while(s < e)
      swap(s++, e--);
}

void reverse_words(char* line) {
  if (line == NULL)
    return; 
  reverse(line, line+strlen(line)-1);
  char *s = line;
  char *e;
  while (*s != '\0') {
    e = s;
    while (*e != ' ' && *e != '\0') ++e;
    --e;
    reverse(s,e);
    s = e+2;
  }
}

c ++：我试图颠倒字符串中的单词顺序（而不是整个字符串）

8 个答案: