⭐ 题目日期：

腾讯 - 2024/12/20

🌳 题目描述：

输入：hello world,god bless you

输出：world hello,you bless god

🕵🏽‍♂️ 面试评估：

这道题主要考察候选人能否正确地实现反转字符串中单词，尤其是处理字符串分割和反转的核心思想，将英语句子中分句的单词逆序输出，通过 ',' 进行分割，分割后逐个处理每个单词并进行单词反转，其中还需要注意空格的去除，确保单词顺序被反转的同时，原始字符串中的逗号分隔符和空格被正确地保留在最终结果中。

🧗难度系数：

⭐️ ⭐️ ⭐️

📝思路分析：

这道题其实是反转字符串单词的变种，原文链接： 相较于传统的字符串翻转（例如输入 s = "the sky is blue" 输出为 "blue is sky the"），增加了额外的要求，即字符串中包含 ',' ，需要按照 ',' 对字符串进行分割后分别处理，然后再将翻转后的各部分拼接起来。

那么我们只需要通过 ',' 将字符串进行分割，分割成若干段独立的子字符串，随后遍历分割后的数组，对分割后的每段子字符串进行逐一处理。

翻转过程：从字符串尾部向前遍历，利用指针 index 逐个定位每个单词的范围：

• 跳过空格找到单词的结束位置
• 继续向前找到单词的起始位置
• 通过 substring 提取单词，并追加到结果 StringBuilder 中
• 使用一个布尔变量 isFirst 来判断是否需要在单词间插入空格，如果是第一个单词，首部就不用插入空格。

每段子字符串翻转完成后，将其重新拼接为新的字符串，在子字符串之间添加 ',' 作为分隔符。需要特别注意的是，在拼接过程中避免多余的分隔符，例如最后一段子字符串后不应再添加 ','

接下来我将以 案例 1 为例进行详细分析

💻代码(Java、Python、C++)：

Java

public String reverseWords(String input) {
    // 将字符串以逗号分割成子字符串, 例 "A B,C D" -> ["A B", "C D"]
    String[] words = input.split(",");

    // 存储结果
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < words.length; i++) {
        String reversedWord = reverse(words[i]);
        sb.append(reversedWord);
        if (i != words.length - 1) {
            sb.append(',');
        }
    }

    return sb.toString();
}

private String reverse(String s) {
    StringBuilder sb = new StringBuilder();
    // 去除前后空格
    s = s.trim();
    int index = s.length() - 1;

    while (index >= 0) {
        // 跳过空格
        while (index >= 0 && s.charAt(index) == ' ') {
            index--;
        }
        if (index < 0) {
            break;
        }

        // 找到单词的结束位置
        int end = index;

        // 找到单词的起始位置
        while (index >= 0 && s.charAt(index) != ' ') {
            index--;
        }

        sb.append(' ').append(s.substring(index + 1, end + 1));
    }
    
    String result = sb.toString();
    return result.substring(1, result.length());
}

Python

def reverse_words(input_str):
    # 将字符串以逗号分割成子字符串, 例 "A B,C D" -> ["A B", "C D"]
    words = input_str.split(",")

    # 存储结果
    result = []
    for word in words:
        reversed_word = reverse(word)
        result.append(reversed_word)
    
    # 通过逗号连接所有反转后的单词
    return ",".join(result)

def reverse(s):
    s = s.strip()  # 去除前后空格
    reversed_str = []
    index = len(s) - 1

    while index >= 0:
        # 跳过空格
        while index >= 0 and s[index] == ' ':
            index -= 1
        if index < 0:
            break

        # 找到单词的结束位置
        end = index

        # 找到单词的起始位置
        while index >= 0 and s[index] != ' ':
            index -= 1

        # 添加单词到结果
        if reversed_str:
            reversed_str.append(' ')  # 单词间加空格
        reversed_str.append(s[index + 1:end + 1])

    return ''.join(reversed_str)

C++

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

using namespace std;

string reverseWords(const string& input) {
    // 将字符串以逗号分割成子字符串
    stringstream ss(input);
    string word;
    vector<string> words;
    
    while (getline(ss, word, ',')) {
        words.push_back(reverse(word));
    }

    // 使用逗号连接反转后的单词
    string result;
    for (size_t i = 0; i < words.size(); ++i) {
        result += words[i];
        if (i != words.size() - 1) {
            result += ',';
        }
    }
    
    return result;
}

string reverse(const string& s) {
    string trimmed = s;
    trimmed.erase(0, trimmed.find_first_not_of(' '));  // 去除前导空格
    trimmed.erase(trimmed.find_last_not_of(' ') + 1);  // 去除尾随空格

    string reversed_str;
    size_t index = trimmed.size() - 1;

    while (index >= 0) {
        // 跳过空格
        while (index >= 0 && trimmed[index] == ' ') {
            --index;
        }
        if (index < 0) {
            break;
        }

        // 找到单词的结束位置
        size_t end = index;

        // 找到单词的起始位置
        while (index >= 0 && trimmed[index] != ' ') {
            --index;
        }

        // 添加单词到结果
        if (!reversed_str.empty()) {
            reversed_str += ' ';  // 单词间加空格
        }
        reversed_str += trimmed.substr(index + 1, end - index);
    }

    return reversed_str;
}

🚵🏻复杂度分析：

时间复杂度: O(n)，其中 n 为字符串的长度

空间复杂度: O(n)，其中 n 为字符串的长度