翻转单词顺序

题目一：给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: “the sky is blue”
输出: “blue is sky the”
示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

无空格字符构成一个单词。
输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

方法一：有多余空格保留，不改变原有空格：先翻转整个字符串 再翻转各个单词（时间复杂度较高）

public class Solution {
    public void reverse(char[] charArray, int start, int end) {
        if (charArray == null || start < 0 || end > charArray.length-1) {
            return;
        }
        while (start < end) {
            char tmp = charArray[start];
            charArray[start] = charArray[end];
            charArray[end] = tmp;
            start++;
            end--;
        }
    }

    public String reverseWords(String s) {
        char[] charArray = s.toCharArray();
        reverse(charArray, 0, charArray.length-1);
        int i = 0;
        for (int j=0; j<str.length; j++) {
            if (str[j] == ' ') {
                reverse(str, i, j-1);
                i = j + 1;
            }
            if (j == str.length-1) {
                reverse(str, i, j);
            }
        }
        return new String(charArray);
    }
}

输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
方法二（思想与方法一同）：首先将整个字符串翻转一下，然后按照空格进行分词，最后对分词的内容进行再翻转。（时间复杂度次之）

class Solution {
    public String reverse(String s) {
        StringBuilder sb = new StringBuilder(s);
        int start = 0;
        int end = s.length()-1;
        while (start < end) {
            char tmp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, tmp);
            start++;
            end--;
        }
        return "" + sb;
    }

    public String reverseWords(String s) {
       String str = s.trim();
        if (str.equals("")){
            return "";
        }
        String[] strList = reverse(str).split("\\s+");
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<strList.length; i++) {
            sb.append(reverse(strList[i]));
            if (i != strList.length-1) {
                sb.append(" ");
            }
        }
        return "" + sb;
    }
}

方法三：Java中的 String的split 函数是用于按指定字符（串）或正则去分割某个字符串，结果以字符串数组形式返回，split("\s+")\s表示匹配任何空白字符，+表示匹配一次或多次。string.trim()去掉字符串首尾的空格。（时间复杂度最低）

class Solution {
    public String reverseWords(String s) {
            String[] a = s.split("\\s+");
            StringBuffer sb = new StringBuffer();
            for(int i = a.length-1;i>=0;i--){
                if(!a[i].equals(""))  {
                sb.append(a[i]);
                sb.append(" ");}
            }
            return sb.toString().trim();
           
    }
}

注意：保留空格和不保留空格时候，属于不同题目。

题目二 ：给定一个字符串，逐个翻转字符串中的每个单词。

示例：

输入: [“t”,“h”,“e”," “,“s”,“k”,“y”,” “,“i”,“s”,” “,“b”,“l”,“u”,“e”]
输出: [“b”,“l”,“u”,“e”,” “,“i”,“s”,” “,“s”,“k”,“y”,” ",“t”,“h”,“e”]
注意：

单词的定义是不包含空格的一系列字符
输入字符串中不会包含前置或尾随的空格
单词与单词之间永远是以单个空格隔开的
进阶：使用 O(1) 额外空间复杂度的原地解法。

    public void reverse(char[] charArray, int start, int end) {
        if (charArray == null || start < 0 || end > charArray.length-1) {
            return;
        }
        while (start < end) {
            char tmp = charArray[start];
            charArray[start] = charArray[end];
            charArray[end] = tmp;
            start++;
            end--;
        }
    }

    public void reverseWords(char[] str) {
        reverse(str, 0, str.length-1);
        int i = 0;
        for (int j=0; j<str.length; j++) {
            if (str[j] == ' ') {
                reverse(str, i, j-1);
                i = j + 1;
            }
            if (j == str.length-1) {
                reverse(str, i, j);
            }
        }
    }

}