C语言用指针实现对给定字符串查找给定的子串并输出第一个子串所在的位置

以下是用指针实现的C语言代码：

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

int main()
{
    char str[100], substr[100];
    int pos = 0;
    printf("请输入一个字符串：");
    gets(str);
    printf("请输入一个子串：");
    gets(substr);
    char *p = strstr(str, substr);  // 使用字符串库函数strstr查找子串
    if (p != NULL)
    {
        pos = p - str;  // 计算子串在字符串中的位置
        printf("第一个子串所在的位置为：%d\n", pos);
    }
    else
    {
        printf("未找到子串！\n");
    }
    return 0;
}

首先通过`gets()`函数获取输入的字符串和子串，并使用`strstr()`函数在字符串中查找子串。如果找到了子串，则将子串在字符串中的位置计算出来，输出位置值；否则输出未找到子串的提示信息。

相关问题

使用C语言，针对给定两组字符串，利用BF算法查找并定位任意给定字符串

在C语言中，Boyer-Moore（BF，Boyer-Moore Hunt）是一种高效的字符串搜索算法，用于在一个大文本串中快速找到一个模式串的首次出现位置。BF算法的核心思想是避开已知不可能匹配的部分，通过两个启发式规则（坏字符规则和好后缀规则）来优化搜索过程。

以下是使用BF算法查找给定字符串的基本步骤：

1. **初始化**：对于目标模式串S，设置i为0；对于文本T，设定j为0作为起始索引。

2. **坏字符规则**：比较S[i]和T[j]是否相等。如果不同，根据字符表，从T的长度减去S的剩余字符数到1（包括1），移动最远的那个字符，使得不匹配的字符位于模式串的尾部，从而提高效率。

3. **好后缀规则**：检查从模式串右端开始到当前位置的子串S[i:]是否等于T[j:]。如果匹配，说明找到了一个匹配的位置，返回j；如果不匹配，则向后移动T的指针j，跳过尽可能多的字符。

4. **循环**：当i小于模式串长度时，继续上述步骤。直到i等于模式串长度，表示没有找到匹配，将j加1回到文本的下一个字符。

5. **返回结果**：如果找到匹配，返回j作为位置；如果没有找到，返回-1表示未找到。

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

int bad_char_rule(char target[], char text[], int pattern_length);
void good_suffix_rule(char target[], char text[], int pattern_length, int j);

int BoyerMooreSearch(char target[], char text[]) {
    int pattern_length = strlen(target);
    int j = 0;

    while (true) {
        if (target[i] == text[j])
            i++, j++;
        else {
            j -= bad_char_rule(target, text, pattern_length);
            if (j < 0)
                return -1;
        }
        
        // Check for good suffix rule after bad character rule
        good_suffix_rule(target, text, pattern_length, j);
        if (i >= pattern_length)
            return j - pattern_length;  // Found a match
    }
}

// Bad Character Rule implementation
int bad_char_rule(char target[], char text[], int pattern_length) {
    int max_distance = pattern_length;
    for (int k = 1; k <= pattern_length; k++)
        if (target[pattern_length - k] != text[text length - k]) {
            max_distance = k - 1;
            break;
        }
    return max_distance;
}

// Good Suffix Rule implementation (not strictly necessary in BF)
void good_suffix_rule(char target[], char text[], int pattern_length, int j) {
    int length = pattern_length;
    while (length > 0 && target[length - 1])
        length--;

    if (length == 0)
        j += pattern_length;
}

int main() {
    char target[] = "needle";
    char text[] = "haystackhaystackneedle";
    int result = BoyerMooreSearch(target, text);
    if (result != -1)
        printf("Pattern found at index %d\n", result);
    else
        printf("Pattern not found\n");
    return 0;
}

用C语言实现，给定一个字符串，输出其中最长的对称子字符串及长度，若有多个则全部输出

在C语言中，你可以使用双指针技巧以及动态规划的方式来解决这个问题。这里是一个简单的示例代码，它会找出字符串中最长的对称子串并输出它们：

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

void findLongestPalindromes(char* str) {
    int len = strlen(str);
    if (len <= 1) {
        printf("单个字符本身就是对称的。\n");
        return;
    }

    int max_len = 1;  // 初始化最长对称子串长度为1
    int start = 0;   // 最长对称子串的起始索引
    bool found = false;

    for (int i = 0; i < len; ++i) {
        // 检查以当前字符为中心的奇数长度子串
        int low = i, high = i;
        while (low >= 0 && high < len && str[low] == str[high]) {
            if (high - low + 1 > max_len) {
                max_len = high - low + 1;
                start = low;
                found = true;
            }
            low--;
            high++;
        }

        // 检查以当前字符和下一个字符为中心的偶数长度子串
        low = i, high = i + 1;
        while (low >= 0 && high < len && str[low] == str[high]) {
            if (high - low + 1 > max_len) {
                max_len = high - low + 1;
                start = low;
                found = true;
            }
            low--;
            high++;
        }
    }

    // 输出结果
    if (found) {
        printf("最长对称子串: ");
        for (int j = start; j < start + max_len; ++j) {
            printf("%c", str[j]);
        }
        printf("\n长度: %d\n", max_len);
    } else {
        printf("输入的字符串没有对称子串。\n");
    }
}

int main() {
    char str[100];
    printf("请输入一个字符串: ");
    fgets(str, sizeof(str), stdin);  // 要去掉换行符
    str[strcspn(str, "\n")] = '\0';  // 去掉换行符

    findLongestPalindromes(str);

    return 0;
}

这个程序首先检查每个字符作为中心点的奇数长度和偶数长度对称子串，然后比较找到的新子串和之前记录的最大长度。当发现更大的对称子串时，更新最大长度和起始索引，并保存结果。如果在整个过程中都没有找到对称子串，则表示输入字符串本身不是对称的。