精华内容
下载资源
问答
  • Sunday算法

    2021-03-22 22:46:30
    Sunday算法 此原理转自其他博客,侵立删 代码为自己写的,希望大家能看懂 原理介绍 Sunday算法由Daniel M.Sunday在1990年提出,它的思想跟BM算法很相似 只不过Sunday算法是从前往后匹配,在匹配失败时关注的是主串...

    Sunday算法

    此原理转自其他博客
    代码为自己写的,x写有大量注释,希望大家能看懂

    原理介绍

    Sunday算法由Daniel M.Sunday在1990年提出,它的思想跟BM算法很相似

    只不过Sunday算法是从前往后匹配,在匹配失败时关注的是主串中参加匹配的最末位字符的下一位字符。

    • 如果该字符没有在模式串中出现则直接跳过,即移动位数 = 模式串长度 + 1;
    • 否则,其移动位数 = 模式串长度 - 该字符最右出现的位置(以0开始) = 模式串中该字符最右出现的位置到尾部的距离 + 1。

    下面举个例子说明下Sunday算法。假定现在要在主串”substring searching”中查找模式串”search”。

    • 刚开始时,把模式串与文主串左边对齐:
      Sunday1

    • 结果发现在第2个字符处发现不匹配,不匹配时关注主串中参加匹配的最末位字符的下一位字符,即标粗的字符 i,因为模式串search中并不存在i,所以模式串直接跳过一大片,向右移动位数 = 匹配串长度 + 1 = 6 + 1 = 7,从 i 之后的那个字符(即字符n)开始下一步的匹配,如下图:
      Sunday2

    • 结果第一个字符就不匹配,再看主串中参加匹配的最末位字符的下一位字符,是’r’,它出现在模式串中的倒数第3位,于是把模式串向右移动3位(m - 3 = 6 - 3 = r 到模式串末尾的距离 + 1 = 2 + 1 =3),使两个’r’对齐,如下:
      Sunday3

    • 匹配成功。

      回顾整个过程,我们只移动了两次模式串就找到了匹配位置,缘于Sunday算法每一步的移动量都比较大,效率很高。

    算法实现

    const int maxNum = 1005;	// 不同的字符个数
    int shift[maxNum];	//下标是字符的int型数,对应的内容是该字符在模式串中最后出现的位置 
    
    //Sunday算法 
    int Sunday(string s1, string s2) {
    	int len1 = s1.length();	//主串长度
    	int len2 = s2.length();	//模式串长度 
    
    	if (len1 < len2)
    		return -1;
    
    	//初始化shift数组,默认移动- 模式串长度+1 -长度
    	for (int i = 0; i < maxNum; i++) {
    		shift[i] = len2 + 1;	
    	}
    
    	//根据模式串预处理shift数组,执行完循环,相应的s2里的字符
    	//都更新到了距离s2右边最近的距离
    	for (int i = 0; i < len2; i++) {
    		shift[ (int)s2[i] ] = len2 - i;
    	}
    
    	int i = 0;	//主串“指针” 
    	int j;		//模式串“指针” 
    	while (i <= len1 - len2) {
    		j = 0;
    
    		while (s1[i + j] == s2[j]) {
    			j++;
    
    			//当j等于s2的长度len2时,s1中有s2子串
    			if (j == len2)
    				return i;
    		}
    
    		//不匹配则根据shift数组更新i指针
    		i += shift[ (int)s1[i+len2] ];
    	}
    
    	//s1中找不到s2子串
    	return -1;
    }
    
    展开全文
  • sunday算法

    2019-09-29 08:02:46
    sunday算法是个特别容易记和理解的算法,但是我看网上很多博客都写错了。所以整理了一下, 防止自己遗忘,sunday算法的原理很简单。 1. 匹配,然后出现不匹配的时候,看主串最后一个元素的下一个元素,从右...

    sunday算法是个特别容易记和理解的算法,但是我看网上很多博客都写错了。所以整理了一下,

     

    防止自己遗忘,sunday算法的原理很简单。

     

     1. 匹配,然后出现不匹配的时候,看主串最后一个元素的下一个元素,从右往左(为什么从右往左)检查子串是否包含(为什么要这样)

    为什么从右往左:因为下一个如果匹配的子串,第一个肯定先和最右边的那个i对应上,这样就跳过了好多。

    2.重新对上以后,再重复一步骤,是不是很简单,但是代码可不简单。

    代码:难点是位置的坐标很容易混,有个好记的办法就是,没有常数+1或者-1

    class Solution {
        public int strStr(String haystack, String needle) {
                if(haystack!=null&&needle.equals(""))
                 return 0;
                int x=0;
                int j=0;
                while(x<haystack.length()&&j<needle.length())
                {
                    int  num=0;
                    while(x+num<haystack.length()&&num<needle.length()&&haystack.charAt(x+num)==needle.charAt(num))
                    {
                        num++;
                    }
                    if(num==needle.length())
                        return x;
                    char p=' ';
                    if(x+needle.length()<haystack.length())
                        p=haystack.charAt(x+needle.length());
                    int loc=needle.lastIndexOf(p);
                    if(loc==-1)
                        x=x+needle.length();
                    else
                    {
                    x=x+needle.length()-loc;
                    }
                }
                return -1; 
        }
    }

     

    转载于:https://www.cnblogs.com/pc-m/p/11444006.html

    展开全文
  • Sunday 算法

    2019-04-27 08:24:52
    但实际上,KMP算法并不比最简单的c库函数strstr()快多少,而BM算法虽然通常比KMP算法快,但BM算法也还不是现有字符串查找算法中最快的算法,有一种比BM算法更快的查找算法即Sunday算法Sunday算法由Daniel M....

    KMP算法和BM算法,这两个算法在最坏情况下均具有线性的查找时间。但实际上,KMP算法并不比最简单的c库函数strstr()快多少,而BM算法虽然通常比KMP算法快,但BM算法也还不是现有字符串查找算法中最快的算法,有一种比BM算法更快的查找算法即Sunday算法。

    Sunday算法由Daniel M.Sunday在1990年提出,它的思想跟BM算法很相似:

    只不过Sunday算法是从前往后匹配,在匹配失败时关注的是文本串中参加匹配的最末位字符的下一位字符。

    1. 如果该字符没有在模式串中出现则直接跳过,即移动位数 = 匹配串长度 + 1;
    2. 否则,其移动位数 = 模式串中最右端的该字符到末尾的距离+1。

    下面举个例子说明下Sunday算法。假定现在要在文本串"substring searching algorithm"中查找模式串"search"。

    1.刚开始时,把模式串与文本串左边对齐:

    在这里插入图片描述
    2.结果发现在第2个字符处发现不匹配,不匹配时关注文本串中参加匹配的最末位字符的下一位字符,即标粗的字符 i,因为模式串search中并不存在i,所以模式串直接跳过一大片,向右移动位数 = 匹配串长度 + 1 = 6 + 1 = 7,从 i 之后的那个字符(即字符n)开始下一步的匹配,如下图:
    在这里插入图片描述
    3.结果第一个字符就不匹配,再看文本串中参加匹配的最末位字符的下一位字符,是’r’,它出现在模式串中的倒数第3位,于是把模式串向右移动3位(r 到模式串末尾的距离 + 1 = 2 + 1 =3),使两个’r’对齐,如下:

    在这里插入图片描述
    4.匹配成功。

    回顾整个过程,我们只移动了两次模式串就找到了匹配位置,缘于Sunday算法每一步的移动量都比较大,效率很高。


    THE END.

    展开全文
  • c#实现sunday算法实例

    2021-01-20 05:39:13
    BM算法是王道,而sunday算法据说是目前最好的改进版,这一点我没有从国外的网站尤其是wiki上找到印证,但中文谈论sunday的文章很多,我就姑且认为它是最好的吧。 代码如下:public static int SundaySearch(string ...
  • 文本串S如下模式串T如下期望从S中找到T的位置。设有指向文本串S的游标i,指向模式串T的游标j。初始i = 0, j = 01:i = 0, j= 0S[i] != T[j], 所以需要向右移动i然后重新和T的开头匹配,那么我们移动多少个字符呢?...

    文本串S如下

    8921d28ef28d666bfbeee28e319ced0f.png

    模式串T如下

    f4a8c451c3c3b0422066d8808b780278.png

    期望从S中找到T的位置。

    设有指向文本串S的游标i,指向模式串T的游标j。初始i = 0, j = 0

    1:i = 0, j= 0

    66e3114849975be53c223714e82de953.png

    S[i] != T[j], 所以需要向右移动i然后重新和T的开头匹配,那么我们移动多少个字符呢?

    现在让我们脑洞大开,从S和T在当前位置末尾对齐的下一个位置看起,也就是目前的S[3]位置,S[3] = E。

    开始向右移动T。

    ---->移动一个字符,S[3]和T[2]对齐,

    20d9a6c72bebc98446f33439f65e5396.png

    明显这个位置是不可能匹配成功的,因为S[3] != T[2]。

    ---->移动两个字符,S[3]和T[1]对齐。

    d5c1387fd7b49f1bb4d60404dbe77cf5.png

    同理,这也不可能匹配成功。

    ---->移动三个字符,S[3]和T[0]对齐。

    0a1a64aa8fbed8994c5f6e96a087fa74.png

    同理,这也不可能匹配成功。

    是不是稍微有点感觉了,好,现在来稍微总结下思路。

    当在位置i(S的游标),j(T的游标)不匹配时,找到对齐后的下一个位置pos的字符C,然后把T中最后一个出现字符C的位置,和S的pos位置对齐,然后重新开始验证匹配,这样才有可能匹配。如果T中不存在字符C,说明T的任何一个位置都不能和S的pos位置匹配,那么只能从S的pos+1的位置开始和T[0]开始匹配了。

    现在按这种方法,来演示一遍。

    第一步:i = 0, j = 0

    67573af5dd1b0411419697f8bade9816.png

    i和j的位置不匹配,找到对齐后的下一个位置pos = 3,字符为E,由于T中不存在字符E,所有设置i = 4(pos的下一个位置), j = 0(j从头匹配)

    第二步:i = 4, j = 0

    a426d2706a64b6497de7a40b4a4af06a.png

    ------------------------

    匹配串:O U R S T R O N G X S E A R C H

    模式串:S E A R C H

    这里我们看到O-S不相同,我们就看匹配串中的O在模式串的位置,没有出现在模式串中。

    匹配串:O U R S T R O N G X S E A R C H

    模式串: _ _ _ _ _ _ _ _ S E A R C H

    移动模式串,使模式串的首字符和O的下一个字符对齐。

    匹配串:O U R S T R O N G X S E A R C H

    模式串:_ _ _ _ _ _ _ _ S E A R C H

    继续比较,N-S不相同,字符R出现在模式串,则后移模式串,将把它们对齐

    匹配串:O U R S T R O N G X S E A R C H

    模式串: _ _ _ _ _ _ _ _ _ _ _ S E A R C H

    展开全文
  • sunday 算法编辑锁定Sunday算法是Daniel M.Sunday于1990年提出的字符串模式匹配。其核心思想是:在匹配过程中,模式串发现不匹配时,算法能跳过尽可能多的字符以进行下一步的匹配,从而提高了匹配效率。中文名sunday...
  • 期待的 BM算法 或者 Sunday 没有出现!鉴于网友的回复,特此声明:我的代码假定字符串中的字符都在ASCII范围内想了解Sunday,可以查作者原著,不难找。By the way,国内有好多 Paper 是对Sunday的改进,我本人是忽略...
  • 之前被KMP的next数组搞的头昏脑胀说不上也是比较烦人的,今天看到还有这么有趣而且高效的算法(比KMP还快),看来有必要做一点笔记了Sunday算法是Daniel M.Sunday于1990年提出的字符串模式匹配算法,其简单、快速的...
  • Sunday算法实现

    2019-03-25 16:21:50
    字符串模式匹配算法 sunday算法实现。说到字符串匹配算法,立马就想到了KMP算法,谁让KMP这么经典呢,各种算法教材里必然有KMP啊。但是KMP算法太复杂了,比KMP更简单更高效的算法就是Sunday算法
  • 其实有很多算法可以来实现字符串查找,暴力的BF算法,经典的KMP算法,BM算法,Sunday算法等等,就效率和实现难度上来说,Sunday算法应该是性价比最高的,效率高,容易理解,实现也比较简单。 Sunday算法是Daniel M....
  • Sunday算法的思想和BM算法中的坏字符思想非常类似。差别只是在于Sunday算法在匹配失败之后,是取目标串中当前和Pattern字符串对应的部分后面一个位置的字符来做坏字符匹配,写了个小例子来实现以下这个算法
  • sunday 算法

    2014-12-01 14:36:30
    SUNDAY 算法描述: 字符串查找算法中,最著名的两个是KMP算法(Knuth-Morris-Pratt)和BM算法(Boyer-Moore)。两个算法在最坏情况下均具有线性的查找时间。但是在实用上,KMP算法并不比最简单的c库函数strstr()快...
  • 同BM算法类似的还有Sunday算法,它们的思想原理有一定相似,但是Sunday算法的匹配速度比BM算法还要快。BM算法的核心思想:在字符串匹配过程中,模式串发现不匹配时,算法能跳过尽可能多的字符以进行下一步的匹配,...
  • 主要介绍了PHP实现的字符串匹配算法,简单描述了sunday算法的概念与原理,并结合实例形式分析了php基于sunday算法实现字符串匹配操作相关技巧,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 816
精华内容 326
关键字:

sunday算法