数据结构实验：串模式匹配

最新推荐文章于 2022-11-13 00:33:31 发布
最新推荐文章于 2022-11-13 00:33:31 发布
阅读量2.2k 收藏 33
点赞数 16
分类专栏： 数据结构实验 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53216148/article/details/121692171
版权

目录

1、实验要求

2、函数实现

        （1）容错处理

        （2）输入主串、子串和匹配起始位置

        （3）朴素的模式匹配算法

        （4）KMP改进算法(Next[ ])   

        （5）KMP改进算法(NextVal[ ])

        （6）修改字符串

3、完整代码

1、实验要求

        实现功能：朴素的模式匹配算法（BF算法）、KMP改进算法(Next[ ])、KMP改进算法(NextVal[ ])。

        主控菜单：

        1．输入主串、子串和匹配起始位置

        2．朴素的模式匹配算法

        3．KMP改进算法(Next[ ])

        4．KMP改进算法(NextVal[ ])

        0．退出管理系统

        实现菜单2的功能：朴素的模式匹配算法，输出各趟匹配详细过程，然后输出匹配总趟数、单个字符比较次数、匹配成功时的位置序号或者匹配失败提示信息。

        实现菜单3的功能：KMP改进算法(Next[ ])，输出Next[ ]各元素的数值、各趟匹配详细过程，然后输出匹配总趟数、单个字符比较次数、匹配成功时的位置序号或者匹配失败提示信息。

        实现菜单4的功能：KMP改进算法(NextVal[ ])，输出NextVal[ ]的各元素的数值、各趟匹配详细过程，然后输出匹配总趟数、单个字符比较次数、匹配成功时的位置序号或者匹配失败提示信息。

        此外还要实现容错处理，检测任何不合规的输入，并给出必要提示。并优化交互界面，让非专业者（陌生人）也能顺利完成运算。

2、函数实现

（1）容错处理

        由于存在容错处理防止程序崩溃，所以需要将输入过程封装成一个函数，如果输入的为正常数字则继续执行功能，如果输入的为乱码或字符，则需重新输入。创建好容错处理函数后，后面的输入只需“int a = Judge()”即可。

int Judge() {
    int j;
    while (true) {
        if (!scanf_s("%d", &j)) {
            cout << "非法字符！请重新输入：";
            while (getchar() != '\n');
        }
        else if (getchar() != '\n') {
            cout << "非法字符！请重新输入：";
            while (getchar() != '\n');
        }
        else if (j < 0) cout << "非法字符！请重新输入：";
        else break;
    }
    return j;
}

（2）输入主串、子串和匹配起始位置

void Action(string& dad, string& son, int& begin) {
    cout << "请输入主串：";
    cin >> dad;

    cout << "请输入子串：";
    cin >> son;
    while (son.size() > dad.size()) {
        cout << "子串长度不能大于主串长度，请重新输入：";
        cin >> son;
    }

    cout << "请输入匹配起始位置(从1开始)：";
    begin = Judge();//容错处理
    while (begin > dad.size()) {
        cout << "主串长度为：" << dad.size() << ",起始位置越界，请重新输入：";
        begin = Judge();
    }
}

（3）朴素的模式匹配算法

void SimpleMatch(string& dad, string& son, int begin) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    while (now_d < dad.size() && now_s < son.size()) {//通过循环输出每趟匹配详细过程
        if (now_s == 0 && now_d < dad.size()) {
            cout << dad << endl;
            for (int i = 0; i < now_d; i++)cout << " ";
        }
        if (dad[now_d] == son[now_s]) {
            book[now_s]++;
            now_d++;
            now_s++;
        }
        else {
            for (int i = 0; i <= now_s; i++) cout << son[i];
            cout << endl;
            cnt++;
            book[now_s]++;
            now_d = now_d - now_s + 1;
            now_s = 0;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
    }
}

（4）KMP改进算法(Next[ ])   

//得到next数组
void GetNext(string son, int next[]) {
    next[0] = -1;
    next[1] = 0;
    int i = 1, j = 0;
    while (i <= son.size()) {
        if (j == 0 || son[i - 1] == son[j - 1]) next[++i] = ++j;
        else j = next[j];
    }
}

//KMP改进算法(Next[ ])
void KMP_next(string& dad, string& son, int begin, int next[]) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    int mark = 0;
    while (now_d < dad.size() && now_s < son.size() || now_s == -1) {//通过循环输出每趟匹配详细过程
        if (mark == 0 && now_d < dad.size()-1) {
            cout << dad << endl;
            for (int i = 0; i < now_d - now_s; ++i) cout << " ";
        }
        if (now_s == -1 || dad[now_d] == son[now_s]) {
            mark = 1;
            if(now_s!=-1)book[now_s]++;
            now_s++;
            now_d++;
        }
        else {
            for (int i = 0; i <= now_s; ++i) cout << son[i];
            cout << endl;
            mark = 0;
            book[now_s]++;
            now_s = next[now_s];
            cnt++;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "next数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << next[i] << " ";
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "next数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << next[i] << " ";
    }
    cout << endl;
}

（5）KMP改进算法(NextVal[ ])

//得到nextval数组
void GetNextval(string son, int next[], int nextval[]) {
    GetNext(son, next);
    GetNext(son, nextval);
    for (int j = 2; j <= son.size(); ++j) {
        if (son[j - 1] == son[next[j] - 1]) {
            nextval[j] = nextval[nextval[j]];
        }
    }
}
//KMP改进算法(Nextval[ ])
void KMP_nextval(string& dad, string& son, int begin, int nextval[]) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    int mark = 0;
    while (now_d < dad.size() && now_s < son.size() || now_s == -1) {//通过循环输出每趟匹配详细过程
        if (mark == 0 && now_d < dad.size()-1) {
            cout << dad << endl;
            for (int i = 0; i < now_d - now_s; ++i) cout << " ";
        }
        if (now_s == -1 || dad[now_d] == son[now_s]) {
            mark = 1;
            if (now_s != -1)book[now_s]++;
            now_s++;
            now_d++;
        }
        else {
            for (int i = 0; i <= now_s; ++i) cout << son[i];
            cout << endl;
            mark = 0;
            book[now_s]++;
            now_s = nextval[now_s];
            cnt++;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "nextval数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << nextval[i] << " ";
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "nextval数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << nextval[i] << " ";
    }
    cout << endl;
}

（6）修改字符串

//修改主串
void DadChange(string& str, int len, int& begin) {
    cout << "将主串修改为：";
    cin >> str;
    while (str.size() < len) {
        cout << "主串长度不能小于子串，请重新输入主串：" << endl;
        cin >> str;
    }
    cout << "请输入匹配起始位置(从1开始)：";
    begin = Judge();
    while (begin > str.size()) {
        cout << "主串长度为：" << str.size() << ",起始位置越界，请重新输入：";
        begin = Judge();
    }
}

//修改子串
void SonChange(string& str, int len) {
    cout << "将子串修改为：";
    cin >> str;
    while (str.size() > len) {
        cout << "子串长度不能大于主串，请重新输入子串：" << endl;
        cin >> str;
    }
}

3、完整代码

        前面函数功能已经全部实现，现在利用while和switch实现功能菜单循环，完整代码附上：

#include<iostream>
#include<string>
using namespace std;

int Judge();//容错函数
void Action(string& dad, string& son, int& begin);//输入主串、子串和匹配起始位置
void SimpleMatch(string& dad, string& son, int begin);//朴素的模式匹配算法
void KMP_next(string& dad, string& son, int begin, int next[]);//KMP改进算法(Next[ ])
void KMP_nextval(string& dad, string& son, int begin, int nextval[]);//KMP改进算法(Nextval[ ])
void GetNext(string son, int next[]);//得到next数组
void GetNextval(string son, int next[], int nextval[]);//得到nextval数组
void DadChange(string& str, int len, int& begin);//修改主串
void SonChange(string& str, int len);//修改子串

int main() {
    string dad, son;//主串和子串
    int begin = 0, n;//起始位置和功能序号
    //进行功能选项
    cout << "==================================" << endl;
    cout << "||请输入功能编号，运行相应功能\t||" << endl;
    cout << "||1.输入主串、子串和匹配起始位置||" << endl;
    cout << "||2.朴素的模式匹配算法\t\t||" << endl;
    cout << "||3.KMP改进算法(Next[ ])\t||" << endl;
    cout << "||4.KMP改进算法(NextVal[ ])\t||" << endl;
    cout << "||5.修改字符串\t\t\t||" << endl;
    cout << "||0.退出管理系统\t\t||" << endl;
    cout << "==================================" << endl;
    while (true) {
        n = Judge();
        if (n < 1 || n>5) break;
        switch (n) {
        case 1:
            Action(dad, son, begin);
            break;
        case 2:
            if (dad.size() == 0 || son.size() == 0)cout << "请先输入主串和子串" << endl;
            else SimpleMatch(dad, son, begin);
            break;
        case 3:
            if (dad.size() == 0 || son.size() == 0)cout << "请先输入主串和子串" << endl;
            else {
                int next[100];
                GetNext(son, next);
                KMP_next(dad, son, begin, next);
            }
            break;
        case 4:
            if (dad.size() == 0 || son.size() == 0)cout << "请先输入主串和子串" << endl;
            else {
                int next[100];
                int nextval[100];
                GetNext(son, next);
                GetNextval(son, next, nextval);
                KMP_nextval(dad, son, begin, nextval);
            }
            break;
        case 5:
            if (dad.size() == 0 || son.size() == 0)cout << "请先输入主串和子串" << endl;
            else {
                int change;
                cout << "请选择修改主串或子串：(1.修改主串 2.修改子串)";
                begin:change = Judge();
                if (change == 1) DadChange(dad,son.size(),begin);
                else if (change == 2) SonChange(son,dad.size());
                else {
                    cout << "输入有误，请重新输入：";
                    goto begin;
                }
            }
            break;
        default:
            break;
        }
        cout << "==================================" << endl;
        cout << "||请输入功能编号，运行相应功能\t||" << endl;
        cout << "||1.输入主串、子串和匹配起始位置||" << endl;
        cout << "||2.朴素的模式匹配算法\t\t||" << endl;
        cout << "||3.KMP改进算法(Next[ ])\t||" << endl;
        cout << "||4.KMP改进算法(NextVal[ ])\t||" << endl;
        cout << "||5.修改字符串\t\t\t||" << endl;
        cout << "||0.退出管理系统\t\t||" << endl;
        cout << "==================================" << endl;
    }
    return 0;
}
//修改主串
void DadChange(string& str, int len, int& begin) {
    cout << "将主串修改为：";
    cin >> str;
    while (str.size() < len) {
        cout << "主串长度不能小于子串，请重新输入主串：" << endl;
        cin >> str;
    }
    cout << "请输入匹配起始位置(从1开始)：";
    begin = Judge();
    while (begin > str.size()) {
        cout << "主串长度为：" << str.size() << ",起始位置越界，请重新输入：";
        begin = Judge();
    }
}

//修改子串
void SonChange(string& str, int len) {
    cout << "将子串修改为：";
    cin >> str;
    while (str.size() > len) {
        cout << "子串长度不能大于主串，请重新输入子串：" << endl;
        cin >> str;
    }
}

//容错处理函数
int Judge() {
    int j;
    while (true) {
        if (!scanf_s("%d", &j)) {
            cout << "非法字符！请重新输入：";
            while (getchar() != '\n');
        }
        else if (getchar() != '\n') {
            cout << "非法字符！请重新输入：";
            while (getchar() != '\n');
        }
        else if (j < 0) cout << "非法字符！请重新输入：";
        else break;
    }
    return j;
}

//得到next数组
void GetNext(string son, int next[]) {
    next[0] = -1;
    next[1] = 0;
    int i = 1, j = 0;
    while (i <= son.size()) {
        if (j == 0 || son[i - 1] == son[j - 1]) next[++i] = ++j;
        else j = next[j];
    }
}

//得到nextval数组
void GetNextval(string son, int next[], int nextval[]) {
    GetNext(son, next);
    GetNext(son, nextval);
    for (int j = 2; j <= son.size(); ++j) {
        if (son[j - 1] == son[next[j] - 1]) {
            nextval[j] = nextval[nextval[j]];
        }
    }
}

//输入主串、子串和匹配起始位置
void Action(string& dad, string& son, int& begin) {
    cout << "请输入主串：";
    cin >> dad;

    cout << "请输入子串：";
    cin >> son;
    while (son.size() > dad.size()) {
        cout << "子串长度不能大于主串长度，请重新输入：";
        cin >> son;
    }

    cout << "请输入匹配起始位置(从1开始)：";
    begin = Judge();
    while (begin > dad.size()) {
        cout << "主串长度为：" << dad.size() << ",起始位置越界，请重新输入：";
        begin = Judge();
    }
}

//朴素的模式匹配算法
void SimpleMatch(string& dad, string& son, int begin) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    while (now_d < dad.size() && now_s < son.size()) {//通过循环输出每趟匹配详细过程
        if (now_s == 0 && now_d < dad.size()) {
            cout << dad << endl;
            for (int i = 0; i < now_d; i++)cout << " ";
        }
        if (dad[now_d] == son[now_s]) {
            book[now_s]++;
            now_d++;
            now_s++;
        }
        else {
            for (int i = 0; i <= now_s; i++) cout << son[i];
            cout << endl;
            cnt++;
            book[now_s]++;
            now_d = now_d - now_s + 1;
            now_s = 0;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
    }
}

//KMP改进算法(Next[ ])
void KMP_next(string& dad, string& son, int begin, int next[]) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    int mark = 0;
    while (now_d < dad.size() && now_s < son.size() || now_s == -1) {//通过循环输出每趟匹配详细过程
        if (mark == 0 && now_d < dad.size()-1) {
            cout << dad << endl;
            for (int i = 0; i < now_d - now_s; ++i) cout << " ";
        }
        if (now_s == -1 || dad[now_d] == son[now_s]) {
            mark = 1;
            if(now_s!=-1)book[now_s]++;
            now_s++;
            now_d++;
        }
        else {
            for (int i = 0; i <= now_s; ++i) cout << son[i];
            cout << endl;
            mark = 0;
            book[now_s]++;
            now_s = next[now_s];
            cnt++;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "next数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << next[i] << " ";
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "next数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << next[i] << " ";
    }
    cout << endl;
}

//KMP改进算法(Nextval[ ])
void KMP_nextval(string& dad, string& son, int begin, int nextval[]) {
    int cnt = 0, now_d = begin - 1, now_s = 0;
    int book[100] = { 0 };
    cout << "匹配具体过程如下：" << endl;
    int mark = 0;
    while (now_d < dad.size() && now_s < son.size() || now_s == -1) {//通过循环输出每趟匹配详细过程
        if (mark == 0 && now_d < dad.size()-1) {
            cout << dad << endl;
            for (int i = 0; i < now_d - now_s; ++i) cout << " ";
        }
        if (now_s == -1 || dad[now_d] == son[now_s]) {
            mark = 1;
            if (now_s != -1)book[now_s]++;
            now_s++;
            now_d++;
        }
        else {
            for (int i = 0; i <= now_s; ++i) cout << son[i];
            cout << endl;
            mark = 0;
            book[now_s]++;
            now_s = nextval[now_s];
            cnt++;
        }
    }
    if (now_s == son.size()) {
        cout << son << endl;
        cout << "匹配成功！" << endl;
        cout << "匹配总趟数为：" << cnt + 1 << endl;
        cout << "匹配成功时的位置序号：" << now_d - now_s + 1 << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "nextval数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << nextval[i] << " ";
    }
    else {
        cout << son << endl;
        cout << "匹配失败！" << endl;
        cout << "匹配总趟数为：" << cnt << endl;
        cout << "子串各个字符比较次数为：";
        for (int i = 0; i < son.size(); i++) cout << book[i] << " ";
        cout << endl;
        cout << "nextval数组如下所示：" << endl;
        for (int i = 1; i <= son.size(); ++i) cout << nextval[i] << " ";
    }
    cout << endl;
}

        以上代码仅供实验参考，若想自身代码能力有确切的提升，还需要融入自己的推演和思考，感谢观看！

故梦余生
关注
  • 16
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数据结构实验 串模式匹配算法
07-18
本实验“数据结构实验：串模式匹配算法”着重于研究如何在长字符串（主串）中查找一个特定的短字符串（模式串）。以下是对实验内容的详细阐述： 首先，我们来了解一下串的基本概念。在C++中，字符串通常用字符数组...
数据结构实验-2串模式匹配算法（串实验）
08-03
实验二 串模式匹配算法（串实验） 实现功能：朴素的模式匹配算法（BF算法）、KMP改进算法(Next[ ])、KMP改进算法(NextVal[ ])。 主控菜单： 1．输入主串、子串和匹配起始位置 2．朴素的模式匹配算法 3．KMP改进算法...
【数据结构】模式匹配算法
inf_lmg的专栏
01-10 1010
模式匹配：子串的定位操作。 模式匹配算法主要有： （1）朴素的模式匹配算法； （2）KMP模式匹配算法   （next数组）； （3）改进的KMP模式匹配算法    （nextval数组）；   比较： 1，时间复杂度：朴素的模式匹配算法为O（（n-m+1）*m），效率很差，KMP算法为O（m+n），大大避免重复遍历情况。 2，改进的KMP算法相对于KMP算法避免了特殊情况下的的多
串的模式匹配算法（超详细）
weixin_45984283的博客
11-13 4884
串的模式匹配算法（简单模式匹配算法、KMP算法、next数组、KMP改进算法）
《数据结构》实验报告四：串的模式匹配（BF算法、KMP算法）
Amentos的博客
10-12 1万+
《数据结构》实验报告：串的模式匹配 - BF算法、KMP算法实现 + 目标串nextval数组算法实现
串的模式匹配算法(KMP算法，BF算法+算法详解+实现代码)
热门推荐
冲出仁川，走出马德里，故事还会再继续
06-10 1万+
串的模式匹配算法(KMP算法，BF算法+算法详解+实现代码) 子串的定位操作是找子串在主串中从第pos个字符后首次出现的位置，又被称为串的模式匹配 一、BF模式匹配算法 BF算法思想:Brute-Force算法又称蛮力匹配算法(简称BF算法),从主串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则继续比较后续字符；否则回溯到主串S的第pos+1个字符开始重新和模式串T进行比较。以此类推，直至模式串T中的每一个字符依次和主串S中的一个连续的字符序列相等，则称模式匹配成功，此时返回模式串T
数据结构与算法：实验报告（串及其应用）
qq_48947478的博客
02-26 1万+
文章目录前言一、实验目的二、实验内容三、实验环境1）使用的操作系统及版本2）使用的编译系统及版本四、实验步骤及说明1、用c语言，设计出串的存储结构总结 前言 计算机上非数值处理的对象大部分是字符串数据，字符串一般简称为串。串是一种特殊的线性表，其特殊性体现在数据元素是一个字符，也就是说，串是一种内容受限的线性表。 提示：以下是本篇文章正文内容，下面案例可供参考 一、实验目的 掌握串类型的实现方法和文本模式匹配方法。 二、实验内容 使用c语言编写顺序串的所有功能，包括串赋值、串比较、串连接、求串长、求..
【串】串的模式匹配算法（BF+KMP）（C语言）
weixin_51424157的博客
01-13 3385
串的模式匹配算法（C语言） 1.字符串的初始化函数 定义一个字符数组S，我们用第0位来存储该字符串的长度，其余位置顺序存储该字符串。（字符串的首位从1开始） 代码实例： #include <stdio.h> #include <string.h> #define N 100 /*静态定义数组的长度*/ typedef char String[N]; // String s1 等价于 char s1[N] int StrAssign(String T,
基于字符串模式匹配算法的病毒感染检测问题 实验四（源代码+实验报告）
05-31
在IT领域，字符串模式匹配是数据结构和算法中一个至关重要的主题，特别是在计算机病毒检测、文本搜索、生物信息学等领域有着广泛的应用。本实验“基于字符串模式匹配算法的病毒感染检测问题”聚焦于如何利用这些算法...
数据结构串的模式匹配实验报告.pdf
09-30
数据结构串的模式匹配实验报告.pdf
字符串模式匹配实验报告
06-04
C语言版本的字符串模式匹配，主要适用于学数据结构的孩纸，数据结构实验报告
数据结构实验5 串运算的实现
09-28
数据结构实验 实验5 串运算的实现 数据结构实验 实验5 串运算的实现 数据结构实验 实验5 串运算的实现 数据结构实验 实验5 串运算的实现 数据结构实验 实验5 串运算的实现
重庆大学数据结构实验报告，串的操作与KMP模式匹配算法源码及结果截屏
06-17
这是重庆大学数据结构实验报告，题目是串的操作与KMP模式匹配算法。里面有完整的实验流程，包括源码及结果截屏
严蔚敏《数据结构》实验三：基于字符串模式匹配算法的病毒感染检测问题
最新发布
06-29
严蔚敏《数据结构》实验三：基于字符串模式匹配算法的病毒感染检测问题
串的模式匹配，KMP算法（解释+源码）
weixin_42158742的博客
08-08 431
解释大部分是直接copy《王道数据结构》 还有一些是自己总结的，可能有些不太对，还请大家指出 KMP算法 关键点：后移多少位，取决于最长的公共前缀和后缀。 例如：abcabcd a --> 0 ab --> 0 abc --> a/ab c/bc --> 0 abca --> a/ab/abc a/ca/bca --> 1 abcab --> a/ab/abc/abca b/ab/cab/bcab --> 2 abcabc ...
串的模式匹配算法
qq_35939417的博客
10-12 716
串的模式匹配算法、朴素的模式匹配算法、KMP模式匹配算法、思路、图解、代码示例、时间复杂度、算法的改进
《数据结构》上机实验(第四章)——串
Miss Z的博客
08-18 5553
1.有两个顺序串s1和s2，求顺序串s3，该串中的字符是s1和s2中的公共字符(即两个串都包含的字符)。 算法思想：扫描s1，对于当前字符s1.data[i]，若它在s2中出现，则将其加人到串s3中，最后返回s3串。 #include<stdio.h> #define MaxSize 50 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int length; }SqString; void Creat
数据结构基础系列(4)：串
09-16
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第4部分串，介绍串的概念、用途，串的顺序和链式存储结构，以及在这两种结构下基本运算的实现，并介绍了模式匹配的经典算法。
数据结构 实验六 模式匹配
qq_55793988的博客
05-11 520
实验目的：掌握模式匹配的基本概念，基本原理。 实验要求：掌握模式匹配的基本概念和基本原理。字符串的逻辑特性、存储表示方法，实现模式匹配算法。 实验内容： 编写程序实现模式匹配算法。 #include<iostream> using namespace std; //BF算法 int BF(const string& s, const string& t) { int i = 0, j = 0; while (i < s.length() &amp
05-串1
08-03
数据结构实验（5）• 串• 串与匹配问题• 串• 串与匹配问题• 字符串匹配只是字符串检索问题的种• 字符串检索：• 判断字符串 A 中是否包含字符串 B；•

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

故梦余生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值