力扣151

解题思路：
第一步，删除首尾空格和单词之间的多余空格，单词之间只留下一个空格；
第二步，整体反转删除空格的字符串
第三步，反转单个单词
对于第三步有两种解法

1. 解法一
   见到空格，就反转之前遇到的非空格的字符串，需要记录每一段非空字符串的长度

string reverseWords(string& s) {
        int count = 0;//记录每一段非空字符串的长度
        int start = 0;//记录每个单词的起始位置
        int end = 0;//记录每个单词的末尾位置
        int idx = 0;//
        remove_space(s);
        reverse(s, 0, s.size() - 1);
        //遇到空格将之前的单词反转回来
        while (idx < s.size())
        {
            while (idx < s.size() && s[idx] != ' ')
            {
                count++;
                idx++;
            }
            //更新待反转单词的起始位置
            start = end;
            end += count;
            
            reverse(s, start, end - 1);
            count = 0;
            idx++;
            end++;//下一个单词的起始位置就是上个单词末尾位置加1
        }
        return s;
    }

2. 解法2
   设置一个标记flag

 string reverseWords(string s)
    {
        remove_space(s);
        reverse(s,0,s.size()-1);
        int start = 0;
        int end = 0;
        bool flag = false;
        for(int i=0;i<s.size();i++)
        {
            if((!flag) || (s[i] != ' ' && s[i-1]==' '))
            {
                start = i;
                flag = true;
            }
            if(flag && s[i]==' ' && s[i-1]!=' ')
            {
                end = i-1;
                flag = false;
                reverse(s,start,end);
            }
            if(flag && (i==s.size()-1) && s[i]!=' ')
            {
                end = i;
                flag = false;
                reverse(s,start,end);
            }
        }
        return s;
    }

总结coding

class Solution {
public:
    void remove_space(string& s)
    {
        int slowptr = 0;
        int fastptr = 0;
        //删除字符串首空格
        while(s.size()>0 && s[fastptr]==' ' && fastptr < s.size())
        {
            fastptr++;
        }
        //删除单词之间的冗余空格
        for(int i=fastptr;i<s.size();i++)
        {
            if( i>1  && s[i] == s[i-1] && s[i]==' ')
            {
                continue;
            }
            else
                s[slowptr++] = s[i];
        }
        //删除单词末尾的空格
        if(slowptr >1 && s[slowptr-1]==' ')
        {
            s.resize(slowptr-1);
        }
        else
        {
            s.resize(slowptr);
        }
    }
    void reverse(string& s,int start,int end)
    {
        for(int i=start,j=end;i<j;i++,j--)
        {
            swap(s[i],s[j]);
        }
    }
    /*string reverseWords(string s)
    {
        remove_space(s);
        reverse(s,0,s.size()-1);
        int start = 0;
        int end = 0;
        bool flag = false;
        for(int i=0;i<s.size();i++)
        {
            if((!flag) || (s[i] != ' ' && s[i-1]==' '))
            {
                start = i;
                flag = true;
            }
            if(flag && s[i]==' ' && s[i-1]!=' ')
            {
                end = i-1;
                flag = false;
                reverse(s,start,end);
            }
            if(flag && (i==s.size()-1) && s[i]!=' ')
            {
                end = i;
                flag = false;
                reverse(s,start,end);
            }
        }
        return s;
    }*/
    
    string reverseWords(string& s) {
        int count = 0;
        int start = 0;
        int end = 0;
        int idx = 0;
        remove_space(s);
        reverse(s, 0, s.size() - 1);
        //遇到空格将之前的单词反转回来
        while (idx < s.size())
        {
            while (idx < s.size() && s[idx] != ' ')
            {
                count++;
                idx++;
            }
            start = end;
            end += count;
          
            reverse(s, start, end - 1);
            count = 0;
            idx++;
            end++;
        }
        return s;
    }

};