力扣热题——查找包含给定字符的单词-CSDN博客

题目链接：2942. 查找包含给定字符的单词 - 力扣（LeetCode）

题目链接：2942. 查找包含给定字符的单词 - 力扣（LeetCode）

注：下述题目描述和示例均来自力扣

题目描述

给你一个下标从 0 开始的字符串数组 words 和一个字符 x 。

请你返回一个 下标数组 ，表示下标在数组中对应的单词包含字符 x 。

注意，返回的数组可以是任意顺序。

示例 1：

输入：words = ["leet","code"], x = "e"
输出：[0,1]
解释："e" 在两个单词中都出现了："leet" 和 "code" 。所以我们返回下标 0 和 1 。

示例 2：

输入：words = ["abc","bcd","aaaa","cbc"], x = "a"
输出：[0,2]
解释："a" 在 "abc" 和 "aaaa" 中出现了，所以我们返回下标 0 和 2 。

示例 3：

输入：words = ["abc","bcd","aaaa","cbc"], x = "z"
输出：[]
解释："z" 没有在任何单词中出现。所以我们返回空数组。

提示：

1 <= words.length <= 50
1 <= words[i].length <= 50
x 是一个小写英文字母。
words[i] 只包含小写英文字母。

解法一：简单拿捏

遍历字符串数组中的每一个单词，每个单词的话，检查它是否包含目标字符 x。如果包含，则记录该单词在原数组中的下标。最后将所有符合条件的下标组成数组返回。整体做法是暴力枚举每个单词并逐个判断字符是否存在，虽然简单但效率足够，适用于题目给出的数据规模限制。

Java写法：

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            if (words[i].indexOf(x) != -1) {
                result.add(i);
            }
        }
        return result;
    }
}

C++写法：

class Solution {
public:
    vector<int> findWordsContaining(vector<string>& words, char x) {
        vector<int> result;
        for (int i = 0; i < words.size(); ++i) {
            if (words[i].find(x) != string::npos) {
                result.push_back(i);
            }
        }
        return result;
    }
};

C写法：

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* findWordsContaining(char** words, int wordsSize, char x, int* returnSize) {
    // 初始化返回大小为0
    *returnSize = 0;
    // 动态分配结果数组，初始大小可以根据需要调整
    int* result = (int*)malloc(sizeof(int) * wordsSize);
    
    for (int i = 0; i < wordsSize; ++i) {
        // 使用 strchr 检查字符是否在单词中
        if (strchr(words[i], x) != NULL) {
            result[(*returnSize)++] = i;
        }
    }

    // 如果没有找到任何匹配项，则释放分配的内存并返回NULL
    if (*returnSize == 0) {
        free(result);
        return NULL;
    }

    return result;
}

Python写法：

class Solution(object):
    def findWordsContaining(self, words, x):
        return [index for index, word in enumerate(words) if x in word]

运行时间

时间复杂度和空间复杂度

时间复杂度分析

外层循环：遍历 words 数组需要 O(n) 的时间，其中 n 是 words 数组的长度。
内层操作：对于 words 数组中的每一个单词，调用 strchr 函数来查找字符 x。假设平均每个单词的长度为 m，则 strchr 的最坏情况时间复杂度是 O(m)，因为它可能需要检查单词中的每个字符。

因此，整体的时间复杂度是 O(n * m)，其中：

n 是 words 数组的长度，
m 是单词的平均长度。

空间复杂度分析

空间消耗：主要的空间消耗在于存储符合条件的单词下标的数组。在最坏的情况下，所有的单词都包含字符 x，此时需要的空间为 O(n)。此外，还有一小部分额外的空间用于变量和函数调用栈。

总结

该题目要求找出字符串数组中包含指定字符x的所有单词下标。解题思路是遍历数组，逐个检查单词是否包含x。算法时间复杂度为O(n*m)（n为数组长度，m为单词平均长度），空间复杂度为O(n)。提供了Java、C++、C和Python四种实现方案，均采用线性扫描和字符串查找方法。题目数据规模较小（n≤50），暴力解法完全适用且高效。