在通过链串存储结构，设计一个算法来计算串t在串s中出现的次数（不计重复的字符），并对算法进行实现和测试

一、实验目的：
本实验旨在本实验旨在通过链串存储结构，设计一个算法来计算串t在串s中出现的次数（不计重复的字符），并对算法进行实现和测试。

二、实验内容：

1. 使用链串存储结构定义字符串，并实现串赋值、串销毁、串复制等操作。
2. 设计countSubstring算法，求串t在串s中出现的次数，不计重复的字符。
3. 编写测试程序，验证算法的正确性

三、实验过程：
实现思路：

1. 使用链串存储结构表示字符串，实现串赋值、串销毁、串复制等基本操作。
2. 设计算法countSubstring，遍历串s的每个位置，依次与串t进行匹配，计算出串t在串s中出现的次数。

实验步骤/实现代码：

#include <iostream>  
#include <cstring> // 用于 strlen  
  
using namespace std;  
  
#define MaxSize 100   
  
typedef struct node  
{  
    char data;  
    struct node *next;  
} LinkString;  
  
// 串赋值运算  
void Assign(LinkString *&s, const char str[])  
{  
    int i = 0;  
    LinkString *p, *tc = s = (LinkString *)malloc(sizeof(LinkString));  
    while (str[i] != '\0') {  
        p = (LinkString *)malloc(sizeof(LinkString));  
        p->data = str[i];  
        tc->next = p;  
        tc = p;  
        i++;  
    }  
    tc->next = NULL;  
}  
  
// 销毁串运算  
void DestroyStr(LinkString *&s)  
{  
    LinkString *p = s, *temp;  
    while (p != NULL) {  
        temp = p;  
        p = p->next;  
        free(temp);  
    }  
    s = NULL;  
}  
  
// 串复制运算算法  
void strCopy(LinkString *&s, LinkString *t)  
{  
    LinkString *p = t->next, *q, *tc = s = (LinkString *)malloc(sizeof(LinkString));  
    while (p != NULL) {  
        q = (LinkString *)malloc(sizeof(LinkString));  
        q->data = p->data;  
        tc->next = q;  
        tc = q;  
        p = p->next;  
    }  
    tc->next = NULL;  
}  
  
// 判断串相等  
int StrEqual(LinkString *s, LinkString *t)  
{  
    LinkString *p = s->next, *q = t->next;  
    while (p != NULL && q != NULL) {  
        if (p->data != q->data)  
            return 0;  
        p = p->next;  
        q = q->next;  
    }  
    return p == NULL && q == NULL; // 如果两个链表都遍历完，说明相等  
}  
  
// 求串t在串s中出现的次数（不计重复的字符）  
int countSubstring(LinkString *s, LinkString *t)  
{  
    int count = 0;  
    LinkString *current = s->next; // 从s的第一个节点开始比较  
    while (current != NULL) {  
        LinkString *tempS = current, *tempT = t->next; // tempT跳过t的头结点  
        while (tempT != NULL) {  
            if (!StrEqual(tempS, tempT)) { // 如果当前位置不匹配  
                break; // 跳出内层循环，尝试下一个位置  
            }  
            tempS = tempS->next; // 继续比较s的下一个字符  
            tempT = tempT->next; // 继续比较t的下一个字符  
        }  
        if (tempT == NULL) { // 如果tempT为空，说明匹配成功  
            count++; // 增加计数  
            current = current->next; // 移动到s的下一个字符继续匹配  
        } else {  
            current = current->next; // 移动到s的下一个位置尝试匹配  
        }  
    }  
    return count;  
}  
  
int main()  
{  
    char sStr[] = "aaaaaaaa";  
    char tStr[] = "aaa";  
  
    LinkString *s = NULL, *t = NULL;  
  
    // 分配并初始化串s和串t  
    Assign(s, sStr);  
    Assign(t, tStr);  
  
    // 计算串t在串s中出现的次数  
    int count = countSubstring(s, t);  
    cout << "The number of occurrences of '" << tStr << "' in '" << sStr << "' is: " << count << endl;  
  
    // 销毁串s和串t以释放内存  
    DestroyStr(s);  
    DestroyStr(t);  
  
    return 0;  
}

实验结果/运行图：

• 输入：s="aaaaaaaa", t="aaa"
• 输出：串t在串s中出现的次数为1