翻转字符串中的单词

给你一个字符串 s ，逐个翻转字符串中的所有 单词 。

单词 是由非空格字符组成的字符串。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”
解释：如果两个单词间有多余的空格，将翻转后单词间的空格减少到只含一个。

请用o(1)的空间复杂度

函数：
1：$.trim() 删除字符串开始和末尾两端的空格
2：逻辑运算符

（1）.&

（1）按位运算符； （2）逻辑运算符

作为逻辑运算符时，&左右两端条件式有一个为假就会不成立，但是两端都会运行，比如（1+2）=4 &（1+2）=3；1+2=4即使为假也会去判断1+2=3是否成立。

（2）.&&——逻辑运算符-一假全假

&&也叫做短路运算符，因为只要左端条件式为假直接不成立，不会去判断右端条件式。

相同点：只要有一端为假，则语句不成立

3：三目运算符

三目运算符“?:”省略中间操作数
在使用三目运算符的时候，我们经常见到的是:
x ? x : y就是if else的简写
如果x为真，就返回x，如果x为假，就返回y。这是最简单最基本的用法。

但是有时候会看到这种用法

x ?: y

？与：之间没有任何操作数，这是什么用法呢？

在通过几个实例的实验后，猜测？与：之间省略了x

也就是说x ? : y 就是 x ? x : y

这样就可以讲的通了。

方法一：递归

class Solution {
    public String reverseWords(String s) {
        s=s.trim();  //去除字符串两端的空格
  //从字符串的最后一个字符开始往前查找，当出现第一个字符为空格时，返回空格之后的字符+空格，然后再次调用reverwords函数，此时的s是去掉已经被查找过的字符串。      
        for(int len=s.length()-1;len>0;len--){
            if(s.charAt(len)==' '){
                String word=s.substring(len+1,s.length());
                return word+" "+reverseWords(s.substring(0,len));
                
            }
        }
    return s;
    }
}

方法二：双指针

class Solution {
    public String reverseWords(String s) {
        s=s.trim();
        int len =s.length();
        int begin =len;
        int end =len;
        while(len-->0){
            if(s.charAt(len)==' ' && begin ==end){
                s =s.substring(0,len)+s.substring(len+1,s.length());
                begin --;
                end --;
            }else if(s.charAt(len)==' ' && begin !=end){
               String word =s.substring(begin,end);
               s= s.substring(0,len) + (end<s.length() ? s.substring(end,s.length()) : "")+ word+" ";
               begin--;
               end =begin;
            }
            else{
                begin --;
            }
        }
    String word =s.substring(0,end);
    s=s.substring(end,s.length())+word;   
    return s;  
    }
}

方法三：栈

// 方法五：栈
    public String reverseWords(String s) {
        // 设置一个栈存放单词
        Stack<String> stack = new Stack<>();
        s.trim();
        String[] wordArray = s.split(" ");
        for (String word : wordArray) {
            if (!word.isEmpty()) {
                stack.add(word);
            }
        }
        StringBuffer stringBuffer = new StringBuffer();
        while (!stack.isEmpty()) {
            stringBuffer.append(stack.pop());
            if (!stack.isEmpty()){
                stringBuffer.append(" ");
            }
        }
        return stringBuffer.toString();
    }

方法四：数组的翻转

/ 方法一;思路：数组的翻转
    // 时间复杂度;O（n）
    // 空间复杂度：O（）
    public String reverseWords_1(String s) {
        String[] wordArray = s.split(" ");
        StringBuffer stringBuffer = new StringBuffer();
        int len = wordArray.length;
        // len-- 先执行表达式后赋值
        // --len 先赋值后执行表达式
        while (len-- > 0) {

            if (!wordArray[len].isEmpty()) {
                if (stringBuffer.length() > 0) {
                    stringBuffer.append(" ");
                }
                stringBuffer.append(wordArray[len]);
            }
        }
        return stringBuffer.toString();
    }