LeetCode-151. 翻转字符串里的单词

题目：

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

示例 1：

输入: “the sky is blue”
输出: “blue is sky the”

示例 2：

输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

说明：

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

解题思路

1、先去掉末尾多余的空格
2、从后往前遍历字符串，遇到字母存入栈中
3、遇到空格从栈中取元素放入目标字符串,中间只保留一个空格
4、遍历完整个字符串后，此时栈中存放的是第一个单词
5、最后从栈中取出该单词存入目标字符串并去掉多余的空格

代码

class Solution {
    public String reverseWords(String s) {
        char[] str = s.toCharArray();
        Stack<Character> stack = new Stack<>();
        String ans = "";
        int i = s.length() - 1;
        int count = 0;
        if(s.equals("")){//字符串为空串
            return ans;
        }
        while(str[i] == ' ' && i > 0){//去掉末尾多余的空格
            i--;
        }
        while(i>=0){
            if (str[i] != ' ') {
                stack.push(str[i]);
                count = 0;
            } else {
                while (!stack.isEmpty()) {
                    ans += stack.peek();
                    stack.pop();
                }
                count++;
                if(count == 1){//中间只保留一个空格
                    ans +=' ';
                }
            }
            i--;
        }
        //第一个单词的翻转
        while (!stack.isEmpty()) {
            ans += stack.peek();
            stack.pop();
        }
        //如果翻转后字符串末尾包含空格，去除
         return ans.charAt(ans.length()-1) == ' '?ans.substring(0,ans.length()-1):ans;
    }
}

复杂度分析

• 时间复杂度：O(N)，其中 N 为输入字符串的长度。
• 空间复杂度：O(N)，用来存储字符串分割之后的结果。

解题思路【使用语言特性】：

1. 使用正则将字符串按空格分割成字符串数组；
2. 使用reverse将字符串数组进行反转；
3. 使用 join 方法将字符串数组拼成一个字符串。

代码实现：

class Solution {
    public String reverseWords(String s) {
        // 除去开头和末尾的空白字符
        s = s.trim();
        // 正则匹配连续的空白字符作为分隔符分割
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
}

复杂度分析

• 时间复杂度：O(N)，其中 N 为输入字符串的长度。
• 空间复杂度：O(N)，用来存储字符串分割之后的结果。

解题思路【双指针+双端队列】：

由于双端队列支持从队列头部插入的方法，因此我们可以沿着字符串一个一个单词处理，然后将单词压入队列的头部，再将队列转成字符串即可

代码实现：

class Solution {
    public String reverseWords(String s) {
        int left = 0, right = s.length() - 1;
        // 去掉字符串开头的空白字符
        while (left <= right && s.charAt(left) == ' ') ++left;

        // 去掉字符串末尾的空白字符
        while (left <= right && s.charAt(right) == ' ') --right;

        Deque<String> ans = new LinkedList<>();
        StringBuilder word = new StringBuilder();
        
        while (left <= right) {
            char c = s.charAt(left);
            if ((word.length() != 0) && (c == ' ')) {
                // 将单词 push 到队列的头部
                ans.offerFirst(word.toString());
                word.setLength(0);
            } else if (c != ' ') {
                word.append(c);
            }
            ++left;
        }
        ans.offerFirst(word.toString());

        return String.join(" ", ans);

    }
}

复杂度分析

• 时间复杂度：O(N)，其中 N 为输入字符串的长度。
• 空间复杂度：O(N)，用来存储字符串分割之后的结果。