华为OD机试E卷 - 增强的strstr（Java & Python& JS & C++ & C ）

增强的strstr函数

在编程中，字符串处理是一项基本而重要的任务。strstr函数是C语言中用于查找子字符串的标准函数，其功能是返回首次出现的子字符串的指针。增强版的strstr函数不仅仅能够返回指针，还需要提供更多功能，例如支持查找多个子字符串、区分大小写和不区分大小写搜索、搜索全部位置等。这篇文章将介绍如何实现这一增强的strstr功能，并提供相应的代码示例，涵盖Java、Python、JavaScript、C++和C语言。

功能需求

1. 支持单个子字符串查找：与标准strstr功能类似。
2. 支持多个子字符串查找：能够一次查找多个子字符串。
3. 区分大小写和不区分大小写：提供选项以便用户选择是否区分大小写。
4. 返回所有匹配位置：返回所有匹配的起始索引，而非仅第一个。

Python实现

我们首先使用Python来实现这个功能。Python的字符串处理非常方便，所以我们可以利用现有的字符串方法来简化代码。

def enhanced_strstr(haystack, needles, case_sensitive=True):
    if not case_sensitive:
        haystack = haystack.lower()
        needles = [needle.lower() for needle in needles]

    indices = {}

    for needle in needles:
        start = 0
        while True:
            start = haystack.find(needle, start)
            if start == -1:  # No more occurrences found
                break
            if needle not in indices:
                indices[needle] = []
            indices[needle].append(start)
            start += 1  # Move to the next search position

    return indices

# 示例使用
haystack = "Hello world, hello Universe"
needles = ["hello", "world", "universe"]
print(enhanced_strstr(haystack, needles, case_sensitive=False))

Java实现

接下来，我们使用Java实现相同的功能，Java的String类同样提供了丰富的字符串处理方法。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class EnhancedStrStr {

    public static Map<String, List<Integer>> enhancedStrStr(String haystack, String[] needles, boolean caseSensitive) {
        Map<String, List<Integer>> result = new HashMap<>();
        String searchHaystack = caseSensitive ? haystack : haystack.toLowerCase();

        for (String needle : needles) {
            String searchNeedle = caseSensitive ? needle : needle.toLowerCase();
            List<Integer> indices = new ArrayList<>();
            int index = searchHaystack.indexOf(searchNeedle);

            while (index != -1) {
                indices.add(index);
                index = searchHaystack.indexOf(searchNeedle, index + 1);
            }

            if (!indices.isEmpty()) {
                result.put(needle, indices);
            }
        }

        return result;
    }

    public static void main(String[] args) {
        String haystack = "Hello world, hello Universe";
        String[] needles = {"hello", "world", "universe"};
        System.out.println(enhancedStrStr(haystack, needles, false));
    }
}

C++实现

在C++中，我们可以利用STL库来实现相似的功能。

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

std::map<std::string, std::vector<int>> enhancedStrStr(const std::string& haystack, const std::vector<std::string>& needles, bool caseSensitive) {
    std::map<std::string, std::vector<int>> result;
    std::string searchHaystack = caseSensitive ? haystack : haystack;

    if (!caseSensitive) {
        std::transform(searchHaystack.begin(), searchHaystack.end(), searchHaystack.begin(), ::tolower);
    }

    for (const auto& needle : needles) {
        std::string searchNeedle = caseSensitive ? needle : needle;

        if (!caseSensitive) {
            std::transform(searchNeedle.begin(), searchNeedle.end(), searchNeedle.begin(), ::tolower);
        }

        size_t pos = searchHaystack.find(searchNeedle);
        while (pos != std::string::npos) {
            result[needle].push_back(pos);
            pos = searchHaystack.find(searchNeedle, pos + 1);
        }
    }

    return result;
}

int main() {
    std::string haystack = "Hello world, hello Universe";
    std::vector<std::string> needles = {"hello", "world", "universe"};
    auto result = enhancedStrStr(haystack, needles, false);

    for (const auto& pair : result) {
        std::cout << pair.first << ": ";
        for (int index : pair.second) {
            std::cout << index << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

C实现

最后，我们来实现C语言版本的增强strstr。

#include <stdio.h>
#include <string.h>
#include <ctype.h>

void enhanced_strstr(const char* haystack, const char* needles[], int needle_count, int case_sensitive) {
    for (int i = 0; i < needle_count; i++) {
        const char* needle = needles[i];
        const char* ptr = haystack;
        int needle_len = strlen(needle);

        while ((ptr = strstr(ptr, needle)) != NULL) {
            if (!case_sensitive) {
                // 处理不区分大小写的情况
                if (strncasecmp(ptr, needle, needle_len) == 0) {
                    printf("Found \"%s\" at position %ld\n", needle, ptr - haystack);
                }
            } else {
                printf("Found \"%s\" at position %ld\n", needle, ptr - haystack);
            }
            ptr++;
        }
    }
}

int main() {
    const char* haystack = "Hello world, hello Universe";
    const char* needles[] = {"hello", "world", "universe"};
    int needle_count = sizeof(needles) / sizeof(needles[0]);
    enhanced_strstr(haystack, needles, needle_count, 0);

    return 0;
}

总结

通过上面的代码，我们实现了一个增强版的strstr函数，能够在不同编程语言中方便地查找子字符串。该实现支持多种功能、方便的使用方法及不同语言的实现，帮助开发者更灵活、高效地处理字符串查找问题。希望这些示例能够为读者提供参考，同时激发对字符串处理深入研究的兴趣。