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

最新推荐文章于 2024-07-24 20:25:39 发布
最新推荐文章于 2024-07-24 20:25:39 发布
阅读量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
    评论
专栏目录
数据结构——串(模式匹配)KMP算法
Snoopy0629的博客
12-06 1043
串的模式匹配算法暴力破解法原理伪代码KMP算法背景计算过程1号算法(Next数组)计算步骤KMP算法伪代码改进的KMP算法(NextVal数组)计算步骤改进KMP算法伪代码 暴力破解法 原理 通过已知的主串S和模式串T，进行匹配，效果如下图所示， 第一步 第二步 第三步 第i步 这里关于书上给出的代码做出解释，首先让主串和模式串从首字符开始进行对比，若相当，则主串的索引与模式串的索引均递增1，在进行匹配，若第二个字符相同，则重复上述步骤，直至模式串的最后一个字符，若匹配中间过程中，存在一个或者多个字
数据结构：模式匹配BF算法
qq_52606674的博客
01-04 2090
BF算法
【数据结构】模式匹配算法
inf_lmg的专栏
01-10 1015
模式匹配：子串的定位操作。 模式匹配算法主要有： （1）朴素的模式匹配算法； （2）KMP模式匹配算法   （next数组）； （3）改进的KMP模式匹配算法    （nextval数组）；   比较： 1，时间复杂度：朴素的模式匹配算法为O（（n-m+1）*m），效率很差，KMP算法为O（m+n），大大避免重复遍历情况。 2，改进的KMP算法相对于KMP算法避免了特殊情况下的的多
数据结构-串的模式匹配
lzlyxxn的博客
05-19 1181
1.朴素算法（暴力） 2.KMP算法 3.KMP算法的进一步优化
数据结构课设：基于字符串模式匹配算法的病毒感染检测问题
Hello大家好，我是Dream，如果帮得到你，那我深感荣幸！交流学习、商务合作：https://bbs.csdn.net/topics/614347534
08-02 7529
数据结构课设：基于字符串模式匹配算法的病毒感染检测问题
《数据结构》实验报告四：串的模式匹配（BF算法、KMP算法）
Amentos的博客
10-12 1万+
《数据结构》实验报告：串的模式匹配 - BF算法、KMP算法实现 + 目标串nextval数组算法实现
数据结构 串的模式匹配
qq_52286530的博客
05-16 1436
实验三 1. 实验目的： 掌握串的模式匹配算法（即BF和KMP算法）设计 2. 仪器与材料： 装有Windows操作系统和VC++6.0编程环境的PC机一台。 3. 实验内容： 编写一个程序exp4-3.cpp，实现顺序串的各种模式匹配运算，并在此基础上完成以下功能 建立目标串s=”abcabcdabcdeabcdefabcdefg”和模式串t=”abcdeabcdefab”。 采用简单匹配算法求t在s中的位置 采用KMP算法求t在s中的位置 4. 实验记录： 数据结构设计： ...
【数据结构】实验六 字符串基本操作及模式匹配算法
weixin_61693556的博客
04-22 2756
实验要求： 1、使用顺序结构存储字符串，完成字符串基本操作：如初始化、求长度、字符串连接等； 2、扩展模式匹配的BF算法（只能实现匹配主串中第一次出现的位置），使其能找出主串中出现模式串的所有位置信息。 3、扩展BF算法使其实现近似匹配，即如果模式串和子串中不同位数小于某个给定阈值，则表示匹配成功。 4、实现KMP算法（选做）。 #include<iostream> #define MAXSIZE 100 // 定义串的最大长度 using namespace std; typedef s.
数据结构 基于字符串模式匹配算法的病毒感染检测问题
热门推荐
fzyz2333的博客
01-28 1万+
数据结构 基于字符串模式匹配算法的病毒感染检测问题实验目的实验内容实验提示 实验目的 1.掌握字符串的顺序存储表示方法。 2.掌握字符串模式匹配算法BF算法或KMP算法的实现。 实验内容 问题描述 医学研究者最近发现了某些新病毒，通过对这些病毒的分析，得知它们的DNA序列都是环状的。现在研究者已收集了大量的病毒DNA和人的DNA数据,想快速检测出这些人是否感染了相应的病毒。为了方便研究，研究者将人的DNA和病毒DNA均表示成由一些字母组成的字符串序列，然后检测某种病毒DNA序列是否在患者的DNA序列中出现过
数据结构实验 串模式匹配算法
07-18
本实验“数据结构实验：串模式匹配算法”着重于研究如何在长字符串（主串）中查找一个特定的短字符串（模式串）。以下是对实验内容的详细阐述： 首先，我们来了解一下串的基本概念。在C++中，字符串通常用字符数组...
数据结构实验-2串模式匹配算法（串实验）
08-03
实验二 串模式匹配算法（串实验） 实现功能：朴素的模式匹配算法（BF算法）、KMP改进算法(Next[ ])、KMP改进算法(NextVal[ ])。 主控菜单： 1．输入主串、子串和匹配起始位置 2．朴素的模式匹配算法 3．KMP改进算法...
基于字符串模式匹配算法的病毒感染检测问题 实验四（源代码+实验报告）
05-31
在IT领域，字符串模式匹配是数据结构和算法中一个至关重要的主题，特别是在计算机病毒检测、文本搜索、生物信息学等领域有着广泛的应用。本实验“基于字符串模式匹配算法的病毒感染检测问题”聚焦于如何利用这些算法...
数据结构串的模式匹配实验报告.pdf
09-30
数据结构串的模式匹配实验报告.pdf
严蔚敏《数据结构》实验三：基于字符串模式匹配算法的病毒感染检测问题
06-29
严蔚敏《数据结构》实验三：基于字符串模式匹配算法的病毒感染检测问题
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 925
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1306
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1362
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 428
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
数据结构实验：串与匹配问题探究
"数据结构实验第五部分，主要探讨了串（字符串）的概念及其在匹配问题中的应用。串是数据结构中的一个重要元素，特别是在文本处理和信息检索中。本实验涉及到了多种字符串匹配算法，如KMP和Rabin-Karp算法，并讨论了...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

故梦余生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值