串的匹配模式

最新推荐文章于 2022-02-28 16:50:50 发布
最新推荐文章于 2022-02-28 16:50:50 发布
阅读量530 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37616150/article/details/79831811
版权 
  串的模式匹配
//3.3.1   朴素的模式匹配（Brute-Force）算法

public class BF 
{
    private static int count=0;                            //记载比较次数

    //返回模式串pattern在目标串target中从begin开始的首次匹配位置，匹配失败时返回-1
    public static int indexOf(String target, String pattern, int begin)
java.lang.String字符串的查找、替换和删除子串操作。

public class DeleteString 
{
    //返回将target串中首个与pattern匹配的子串删除后的字符串
    public static String deleteFirst(String target, String pattern)
    {
        int i=target.indexOf(pattern);
        if (i==-1)
            return target;
        return target.substring(0,i)+target.substring(i+pattern.length());
    }
    
    //返回将target串中所有与pattern匹配的子串删除后的字符串
    public static String deleteAll(String target, String pattern)
    {
        int i=target.indexOf(pattern);
        while (i!=-1)
        {
            target = target.substring(0,i)+target.substring(i+pattern.length());
            i=target.indexOf(pattern,i);
        }
        return target;
    }

    public static void main(String args[]) 
    {
        //图3.11，替换子串
//        String target="ababdabcdabcabc", pattern="abc", replacement="xy";   //例3.3数据
        String target="aaaa", pattern="a", replacement="ab";   //例3.4数据

        System.out.println("\""+target+"\".indexOf(\""+pattern+"\")="+target.indexOf(pattern));
        System.out.println("\""+target+"\".replaceFirst(\""+pattern+"\", \""+replacement+"\")="+
                target.replaceFirst(pattern,replacement));
        System.out.println("\""+target+"\".replaceAll(\""+pattern+"\", \""+replacement+"\")="+
                target.replaceAll(pattern,replacement));

        //图3.12，删除子串
        System.out.println("deleteFirst(\""+target+"\", \""+pattern+"\")="+deleteFirst(target, pattern));
        System.out.println("deleteAll(\""+target+"\", \""+pattern+"\")="+deleteAll(target, pattern));
    }
}

/*
程序运行结果如下：
//例3.3数据
"ababdabcdabcabc".indexOf("abc")=5
"ababdabcdabcabc".replaceFirst("abc", "xy")=ababdxydabcabc
"ababdabcdabcabc".replaceAll("abc", "xy")=ababdxydxyxy
deleteFirst("ababdabcdabcabc", "abc")=ababddabcabc
deleteAll("ababdabcdabcabc", "abc")=ababdd

//例3.4数据
"aaaa".indexOf("a")=0
"aaaa".replaceFirst("a", "ab")=abaaa
"aaaa".replaceAll("a", "ab")=abababab
deleteFirst("aaaa", "a")=aaa
deleteAll("aaaa", "a")=

*/

int i=begin, j=0; //i、j分别为目标串和模式串当前字符的下标 count=0; while (i<target.length()) { if (target.charAt(i)==pattern.charAt(j)) //若当前两字符相等，则继续比较后续字符 { i++; j++; } else //否则i、j回溯，进行下一次匹配 { i=i-j+1; //目标串下标i退回到下一个待匹配子串首字符 j=0; //模式串下标j退回到0 } count++; if (j==pattern.length()) //一次匹配结束，匹配成功 { System.out.println("BF.count="+BF.count); return i-j; //返回匹配的子串序号 } } } System.out.println("BF.count="+BF.count); return -1; //匹配失败时返回-1 } //返回模式串pattern在目标串target中从0开始的首次匹配位置，匹配失败时返回-1 public static int indexOf(String target, String pattern) { return BF.indexOf(target, pattern, 0); } public static void main(String args[]) { String target="ababdabcd", pattern="abc"; //图3.10，BF用例// String target="aabaaa", pattern="aab"; //图3.13(a)，匹配成功，最好情况// String target="aaaaa", pattern="aab"; //图3.13(b)，最坏情况，匹配不成功// String target="aaaab", pattern="aab"; //最坏情况，匹配成功 System.out.println("BF.indexOf(\""+target+"\"，\""+pattern+"\")="+BF.indexOf(target,pattern)); }}/*程序运行结果如下：BF.count=12BF.indexOf("ababdabcd"，"abc")=5 //图3.10，BF用例BF.count=3BF.indexOf("aabaaa"，"aab")=0 //图3.13(a)，匹配成功，最好情况BF.count=11BF.indexOf("aaaaa"，"aab")=-1 //图3.13(b)，最坏情况，匹配不成功BF.count=9BF.indexOf("aaaab"，"aab")=2 //最坏情况，匹配成功*/ 
 java.lang.StringBuffer字符串的替换和删除子串操作。

public class ReplaceStringBuffer
{
    //将target串中首个与pattern匹配的子串替换成replacement，返回替换后的target串，改变target串
    public static StringBuffer replaceFirst(StringBuffer target, String pattern, String replacement)
    {
        int i=target.indexOf(pattern);
        if(i!=-1)
        {
            target.delete(i, i+pattern.length());          //删除i～i+pattern.length()-1的子串
            target.insert(i, replacement);                 //在第i个字符处插入replacement串
        }
        return target;
    } 
    
    //将target串中所有与pattern匹配的子串全部替换成replacement，返回替换后的target串，改变target串
    public static StringBuffer replaceAll(StringBuffer target, String pattern, String replacement)
    {
        int i=target.indexOf(pattern);
        while (i!=-1)
        {
            target.delete(i, i+pattern.length());
            target.insert(i, replacement);
            i=target.indexOf(pattern, i+replacement.length());
//            i=target.indexOf(pattern, i+1);            //错
        }
        return target;
    } 

    //删除target串中首个与pattern匹配的子串，返回删除后的target串，改变target串
    public static StringBuffer deleteFirst(StringBuffer target, String pattern)
    {
        int i=target.indexOf(pattern);
        if(i!=-1)
            target.delete(i, i+pattern.length()); 
        return target;
    }
        
    public static void main(String args[]) 
    {
        StringBuffer target = new StringBuffer("ababdabcdabcabc"); //例3.3 数据
        String pattern="abc", replacement="xy";
//        StringBuffer target = new StringBuffer("aaaa");    //例3.4 数据
//        String pattern="a", replacement="ab";

        System.out.println("replaceFirst(\""+target+"\", \""+pattern+"\", \""+replacement+"\")="+
                replaceFirst(target, pattern, replacement));
        System.out.println("replaceAll(\""+target+"\", \""+pattern+"\", \""+replacement+"\")="+
                replaceAll(target, pattern, replacement));
        pattern=replacement;
        System.out.println("deleteFirst(\""+target+"\", \""+pattern+"\")="+deleteFirst(target, pattern));
        System.out.println("deleteAll(\""+target+"\", \""+pattern+"\")="+deleteAll(target, pattern));

        System.out.println("removeAll(\""+target+"\", \""+pattern+"\")="+removeAll(target, pattern));
    }
    
    //习题3，【例3.4】思考题 
    //删除target串中所有与pattern匹配的子串，返回删除后的target串，改变target串
    public static StringBuffer deleteAll(StringBuffer target, String pattern)
    {
        int i=target.indexOf(pattern);
        while (i!=-1)
        {
            target.delete(i, i+pattern.length());
            i=target.indexOf(pattern, i);
        }
        return target;
    }
    
    //删除target串中所有与pattern匹配的子串，返回删除后的target串，改变target串
    //改进上述deleteAll()方法，对StringBuffer字符串删除所有匹配子串，字符一次移动到位
    public static StringBuffer removeAll(StringBuffer target, String pattern)
    {
        int m=target.length(), n=pattern.length();
        int i=target.indexOf(pattern), k=i;
        while (k!=-1)
        {
            int j=k+n;
            k=target.indexOf(pattern, j);
            while (k>0 && j<k || k<0 && j<m)
                target.setCharAt(i++, target.charAt(j++));
        }
        target.setLength(i);                          //设置target串长度为i
        return target;
    }
}

/*
程序运行结果如下：
//例3.3 数据
replaceFirst("ababdabcdabcabc", "abc", "xy")=ababdxydabcabc
replaceAll("ababdxydabcabc", "abc", "xy")=ababdxydxyxy
deleteFirst("ababdxydxyxy", "xy")=ababddxyxy
deleteAll("ababddxyxy", "xy")=ababdd
        
//例3.4 数据
replaceFirst("aaaa", "a", "ab")=abaaa
replaceAll("abaaa", "a", "ab")=abbababab
deleteFirst("abbababab", "ab")=bababab
deleteAll("bababab", "ab")=b
*/

/*
程序设计说明:
1、replaceAll()方法
       如果while中语句如下，当pattern="a", replacement="ab"时，死循环。
    i=target.indexOf(pattern, i);
    如果while中语句如下，当pattern="a", replacement="aab"时，死循环。
    i=target.indexOf(pattern, i+1);
*/

KMP算法：

public class KMP 
{
	private static int count=0;                            //记载比较次数
	private static int[] next;                             //模式串pattern改进的next数组
	private static int[] nextk;                            //模式串pattern未改进的next数组

    //返回模式串pattern在目标串target中从begin开始的首次匹配位置，匹配失败时返回-1
    public static int indexOf(String target, String pattern, int begin)
    {
        if (pattern.length()>0 && target.length()>=pattern.length())
        {                                                  //当目标串比模式串长时进行比较
            int i=begin, j=0;                              //i、j分别为目标串、模式串当前比较字符下标
            count=0;   
            nextk = getNextk(pattern);
            System.out.println("nextk[]: "+toString(nextk));
            next = getNext(pattern);                       //返回模式串pattern改进的next数组
            System.out.println("next[]:  "+toString(next));

            while (i<target.length())
            {
                if (j!=-1)
                    System.out.println("KMP.count="+KMP.count+"，i="+i+"，j="+j+"，"+target.charAt(i)+"=="+pattern.charAt(j)+"？");
                	
                if (j==-1 || target.charAt(i)==pattern.charAt(j))
                {                                          //若条件成立（当前两字符相等），则继续比较后续字符
                    i++;
                    j++;
                }
                else                                       //否则目标串下标i不回溯，进行下次匹配
                    j=next[j];                             //模式串下标j退回到next[j]

                if(j!=-1) count++;
                if (j==pattern.length())                   //一次匹配结束，匹配成功
                {
                    System.out.println("KMP.count="+KMP.count);
                    return i-j;                            //返回匹配的子串序号
                }
            }
        }
        System.out.println("KMP.count="+KMP.count);
        return -1;                                         //匹配失败
    }
    //返回模式串pattern在目标串target中从0开始的首次匹配位置，匹配失败时返回-1
    public static int indexOf(String target, String pattern)
    {
        return indexOf(target, pattern, 0);
    }

    private static int[] getNextk(String pattern)          //返回模式串pattern的next数组
    {
        int j=0, k=-1;
        int[] next=new int[pattern.length()];
        next[0]=-1;
        while (j<pattern.length()-1)
            if (k==-1 || pattern.charAt(j)==pattern.charAt(k))
            {
                j++;
                k++;
                next[j]=k;                                 //有待改进
            }
            else k=next[k];
        return next;
    }

    private static int[] getNext(String pattern)           //返回模式串pattern改进的next数组
    {
        int j=0, k=-1;
        int[] next=new int[pattern.length()];
        next[0]=-1;
        while (j<pattern.length()-1)
            if (k==-1 || pattern.charAt(j)==pattern.charAt(k))
            {
                j++;
                k++;
                if (pattern.charAt(j)!=pattern.charAt(k))  //改进之处
                    next[j]=k;
                else
                    next[j]=next[k];  
            }
            else k=next[k];
        return next;
    }

    private static String toString(int[] next)             //输出next[]数组
    {
        String str="";
        for (int i=0; i<next.length; i++)
        	str += next[i]+" ";
        return str;
    }

    public static void main(String args[]) 
    {
//    	  String target="abdabcabbabcabc", pattern="abcabc"; //图3.17
//          String target="ababdabcd", pattern="abc";        //BF用例，图3.10
//          String target="abcabdabcabcaa", pattern="abcabdabcabcaa";  //表3.4
//          String target="aaaaa", pattern="aab";              //最坏情况，匹配不成功，图3.13(b)
//          String target="aaaab", pattern="aab";           //最坏情况，匹配成功

        //习题3
      String target="ababaab", pattern="aab";      //习3.12①
//        String target="aaabaaaab", pattern="aaaab";      //习3.12②
//      String target="acabbabbabc", pattern="abbabc";    //习3.12③
//      String target="acabcabbabcabc", pattern="abcabaa";    //习3.12④
//        String target="aabcbabcaabcaababc", pattern="abcaababc"; //习3.12⑤，张乃孝书

        System.out.println("KMP.indexOf(\""+target+"\", \""+pattern+"\")="+KMP.indexOf(target, pattern));
    }
}

/*
程序运行结果如下：
KMP.indexOf("abdabcabbabcabc", "abcabc")=9       //图3.17
nextk[]: -1 0 0 0 1 2 
next[]:  -1 0 0 -1 0 0 
KMP.count=17

KMP.indexOf("ababdabcd", "abc")=5                //BF用例，图3.10
nextk[]: -1 0 0 
next[]:  -1 0 0 
KMP.count=10

KMP.indexOf("abcabdabcabcaa", "abcabdabcabcaa")=0  //表3.4
nextk[]: -1 0 0 0 1 2 0 1 2 3 4 5 3 4 
next[]:  -1 0 0 -1 0 2 -1 0 0 -1 0 5 -1 4 
KMP.count=14

KMP.indexOf("aaaaa", "aab")=-1                   //图3.13(b)，最坏情况，匹配不成功，比较n+m次
nextk[]: -1 0 1 
next[]:  -1 -1 1 
KMP.count=8

KMP.indexOf("aaaab", "aab")=2                    //最坏情况，匹配成功，O(n+m)
nextk[]: -1 0 1 
next[]:  -1 -1 1 
KMP.count=7

//习题3，//习3.12
KMP.indexOf("ababaab", "aab")=4                  //习3.12①
nextk[]: -1 0 1 
next[]:  -1 -1 1 
KMP.count=7

KMP.indexOf("aaabaaaab", "aaaab")=4              //习3.12②
nextk[]: -1 0 1 2 3 
next[]:  -1 -1 -1 -1 3 
KMP.count=9

KMP.indexOf("acabbabbabc", "abbabc")=5           //习3.12③
nextk[]: -1 0 0 0 1 2 
next[]:  -1 0 0 -1 0 2 
KMP.count=13

KMP.indexOf("acabcabbabcabc", "abcabaa")=-1       //习3.12④
nextk[]: -1 0 0 0 1 2 1 
next[]:  -1 0 0 -1 0 2 1 
KMP.count=18

KMP.indexOf("aabcbabcaabcaababc", "abcaababc")=9   //习3.12⑤,张乃孝书
nextk[]: -1 0 0 0 1 1 2 1 2 
next[]:  -1 0 0 -1 1 0 2 0 0 
KMP.count=20




KMP.indexOf("abbabaaba", "aba")=3                 //BF用例
nextk[]: -1 0 0 
next[]:  -1 0 -1 
KMP.count=6

*/


bozzzhdz
关注
专栏目录
串的模式匹配算法
sgz
02-18 1110
  串(又称字符串)是由n(n≥0)个字符组成的有限序列，它是数据元素为单个字符的特殊线性表。串可以用顺序存储方式或者链式存储方式进行存储。模式匹配是串最重要和最复杂的一个操作，其实也就是串的查找，其中Brute-Force算法和KMP算法是两种最经常使用的顺序存储结构下的串的模式匹配算法。   模式匹配操作的具体含义是：   在主串（也称做目标串)S中，从位置start开始查找是否存在子串(也称...
java 字符串匹配abba_字符串匹配模式问题
weixin_42523720的博客
03-02 1231
题目大意：有一个字符串它的构成是词 + 空格的组合，如“北京 杭州 杭州 北京”,要求输入一个匹配模式(简单的以字符来写)， 比如 aabb, 来判断该字符串是否符合该模式。例子：pattern = "abba", str="北京 杭州 杭州 北京" 返回 turepattern = "aabb", str="北京 杭州 杭州 北京" 返回 falsepattern = "abc", str="北...
串的模式匹配
11-22 787
串是由零个或多个字符组成的有限序列。 Index(S, T, pos) 子串的定位操作通常称作串的模式匹配(T称为模式串)。
字符串 模式匹配
weixin_33816300的博客
03-19 149
要点 模式匹配是数据结构中字符串的一种基本运算，给定一个子串，要求在某个字符串中找出与该子串相同的所有子串，这就是模式匹配。 假设P是给定的子串，T是待查找的字符串，要求从T中找出与P相同的所有子串，这个问题成为模式匹配问题。P称为模式，T称为目标。如果T中存在一个或多个模式为P的子串，就给出该子串在T中的位置，称为匹配成功；否则匹配失败。 文中代码是本人自己写的，实测有效，含JAV...
数据结构实验-2串模式匹配算法（串实验）
08-03
实验二 串模式匹配算法（串实验） 实现功能：朴素的模式匹配算法（BF算法）、KMP改进算法(Next[ ])、KMP改进算法(NextVal[ ])。 主控菜单： 1．输入主串、子串和匹配起始位置 2．朴素的模式匹配算法 3．KMP改进算法...
用C++实现BM的字符串模式匹配算法
07-02
本篇文章将深入探讨如何使用C++实现Bad Character Rule（坏字符规则）和Good Suffix Rule（好后缀规则）来优化Boyer-Moore（BM）字符串匹配算法。BM算法以其高效的性能在文本搜索、数据挖掘等多个领域广泛应用。 ...
C语言数据结构中串的模式匹配
08-30
C语言数据结构中串的模式匹配 C语言数据结构中串的模式匹配是指在主串S中查找子串T的位置，模式匹配是数据结构中的一种常见问题。模式匹配可以使用朴素算法和KMP算法实现。 朴素算法的实现： 朴素算法是一种简单...
基于字符串模式匹配算法的病毒感染检测问题 实验四（源代码+实验报告）
05-31
在IT领域，字符串模式匹配是数据结构和算法中一个至关重要的主题，特别是在计算机病毒检测、文本搜索、生物信息学等领域有着广泛的应用。本实验“基于字符串模式匹配算法的病毒感染检测问题”聚焦于如何利用这些算法...
串、串的模式匹配算法（子串查找）BF算法、KMP算法
Lucky小黄人的博客
08-20 321
串的定长顺序存储#define MAXSTRLEN 255,//超出这个长度则超出部分被舍去，称为截断 串的模式匹配： 串的定义：0个或多个字符组成的有限序列S = 'a1a2a3…….an ' n = 0时为空串串的顺序存储结构：字符数组，串的长度就是数组末尾‘\0'前面的字符个数数组需在定义时确定长度，有局限性数组的最大长度二：串的堆分配存储表示typedef struct { ch...
模式匹配(子串问题)
清风君
05-23 415
B-F算法 就是暴力搜索，易于理解，效率不高 KMP算法 关键就是预处理NEXT数组，利用之前的失败信息减少主串匹配次数。不需要回溯是关键啦~ #include #include using namespace std; template class Node { private: public:         typedef struct pNode
33、串的模式匹配－Brute-Force算法
hopegrace的博客
02-25 433
一、与串相关的概念 1、串（或字符串）是由零个或多个字符组成的有限序列。一般记作：s=〃c0c1c2…cn-1〃(n≥0)。零个字符的串称为空串，通常以两个相邻的双引号来表示空串，仅由空格组成的的串称为空格串，如：s=〃〃； 2、串与线性表的异同。字符串一般简称为串，可以将它看作是一种特殊的线性表，这种线性表的数据元素的类型总是字符型的，字符串的数据对象约束为字符集。在线性表的基本操...
KMP算法中的next函数
跟acm say goodbye
07-17 869
KMP算法详解看 http://www.matrix67.com/blog/archives/115    next[i]表示当模式串T[i]与主串失配时，模式串的索引回溯到next[i]，主串的索引不变  下面串的下标均从0开始                              -1                                 i==0
串的模式匹配算法总结（朴素模式匹配及求next数组）
Six23333的博客
09-11 886
系列文章目录 文章目录系列文章目录一、朴素模式匹配（代码及图示）二、KMP算法求NEXT数组1.求next数组2.匹配三、改进KMP算法（nextval数组求法） 一、朴素模式匹配（代码及图示） #define MaxLEN 255 typedef struct{ char ch[MaxSize]; int length }SString; int Index(SString S, SString T) { int i = 1 , j = 1; while( i &l
《数据结构严蔚敏 》4.7习题
pumpkin_lion的博客
02-28 1561
2（2） 设目标为t = “abcaabbabcabaacbacba"，模式串为p = ”abcabaa“。 1⃣️ 计算模式p的nextval函数值； #include <stdio.h> #include <string.h> #define MAXLEN 255 typedef struct{ char ch[MAXLEN]; int length; }SString; void get_nextval(SString t,int nextval[]
java数据结构叶核亚_数据结构Java版叶核亚第4版样卷及答案.doc
weixin_31480911的博客
02-21 734
数据结构Java版叶核亚第4版样卷及答案《数据结构(Java版)》课程样卷教材：《数据结构(Java版)(第4版)》，叶核亚编著，电子工业出版社，2015年7月出版。试题范围：第1～9章，掌握基础原理，熟悉经典算法问答题编程题重点是：1.单/双链表 2.二叉树/树，递归算法。这是必须掌握的，即使部分学生掌握不了递归算法，也必须考。不考内容：Floyd，衡二叉树，第10章。已知java.lang.S...
正则表达式的验证
梦溪笔谈
07-16 666
java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳). Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工...
labview字符串匹配模式
最新发布
07-14
在LabVIEW中，字符串匹配模式是一种字符串处理的技术，用于确定一个字符串是否符合特定的模式。 LabVIEW提供了强大的字符串处理功能，包括字符串比较、替换、搜索和匹配等。字符串匹配模式主要利用正则表达式来匹配...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值