（一）字符串采用链式存储结构，设计求子串的算法； （二）字符串采用链式存储结构，设计删除子串的算法； （三）字符串采用顺序存储结构，设计模式匹配的BF算法。用C语言编写完整代码

（一）对于链式存储的字符串，我们可以使用滑动窗口或KMP算法来查找子串。这里简述一种滑动窗口思路：

typedef struct Node {
    char data;
    struct Node *next;
} ListNode;

void findSubstring(ListNode* str, char* subStr) {
    int len1 = strlen(str->data), len2 = strlen(subStr);
    if (len2 > len1) return; // 如果子串比原串长，直接返回
    int i = 0, j = 0;
    while (i < len1 && j < len2) {
        if (str->data[i] == subStr[j]) {
            i++;
            j++;
        } else {
            if (j != 0) j = 0; // 当前字符不符，回溯到上一个已匹配字符
            else i++; // 否则继续比较下一个字符
        }
    }
    if (j == len2) printf("Substring found at index %d\n", i - j); // 子串存在
    else printf("Substring not found\n");
}

// 其他部分...

（二）删除子串的链式存储字符串算法可以采用双指针法，遍历一次原串并在找到子串时将其后面的节点跳过：

void deleteSubstring(ListNode** head, char* subStr) {
    ListNode* cur = *head, *prev = NULL, *temp;
    int len2 = strlen(subStr);

    while (cur) {
        if (strncmp(cur->data, subStr, len2) == 0) { // 比较是否相等
            if (!prev) *head = cur->next; // 第一个字符就是子串，更新头指针
            else prev->next = cur->next; // 删除当前节点
            free(cur); // 释放内存
        } else {
            prev = cur;
        }
        cur = cur->next;
    }
}

（三）使用Boyer-Moore算法（BF算法）在顺序存储的字符串中进行模式匹配，这个算法跳过了大部分不需要检查的部分，提高了效率：

#include "string.h"

int badCharShift(char target, char* pattern) {
    for (char c : pattern)
        if (c == target)
            return 0; // 找到目标字符，返回0表示最坏情况
    return pattern[strlen(pattern)]; // 如果没找到，用最后一个字符作为偏移量
}

void boyerMooreMatch(char* text, char* pattern) {
    int n = strlen(text), m = strlen(pattern);
    int i = m - 1, j;

    while (i < n) {
        int skip = m - 1;
        for (j = m - 1; j >= 0 && pattern[j] == text[i - j]; j--) skip = 0; // 遇到匹配字符，清零跳过位

        if (skip > 0) i -= skip + 1; // 跳过部分字符
        else i += 1; // 没有找到匹配，简单前进一位
    }

    if (j == 0) printf("Pattern found\n");
    else printf("Pattern not found\n");
}

// 其他部分...