ip java regex 匹配 java 匹配算法

文章目录

• 字符串匹配算法

• 1. 蛮力法（BF算法）
• 2. RK算法：
• 3. KMP算法
• 4. KMP模式匹配算法的改进

字符串匹配算法

  检查模式P是否另一个字符串T（T代表文本）的子串，因为要检查整个定长的字符串P，所以有时这些算法称为精确字符串匹配算法。此算法通常输入为原字符串（string）和子串（pattern），要求返回子串在原字符串中首次出现的位置。比如原字符串为“ABCDEFG”，子串为“DEF”，则算法返回3。常见的算法包括：BF（Brute Force，暴力检索）、RK（Robin-Karp，哈希检索）、KMP（教科书上最常见算法）、BM（Boyer Moore）、Sunday等，下面实现BF和KMP算法。

1. 蛮力法（BF算法）

对于文本T中的每个可能的位置，检查P是否匹配，由于文本T的长度为n，模式P的长度m， 所以T的最后m -1个位置无需检查，即有n-m+1个可选的位置来比较。

/**
	 * 搜索模式字符串P在文本字符串T中第一次出现的位置的蛮力解法
	 * 对于文本T中的每个可能的位置，检查P是否匹配，由于文本T的长度为n，模式P的长度为m，
	 * 所以T的最后m - 1个位置无需检查，即有n-m+1个可选的位置来比较。
	 * @param T
	 * @param P
	 * @return
	 */
	private static int[] F;
	public static int bruteForceStringMatch(String T, String P) {
		char[] t = T.toCharArray();
		char[] p = P.toCharArray();
		int n = t.length;
		int m = p.length;
		
		for(int i = 0; i < n - m + 1; i ++) {
			int j = 0;
			while(j < m && p[j] == t[i + j])
				j++;
			if(j == m) {
				return i;
			}				
		}	
		return -1;
	}

时间复杂度为O（（n-m+1）m）=O（nm）
空间复杂度为O（1）

2. RK算法：

RK算法是对BF算法的一个改进：在BF算法中，每一个字符都需要进行比较，并且当我们发现首字符匹配时仍然需要比较剩余的所有字符。而在RK算法中，就尝试只进行一次比较来判定两者是否相等。

RK算法也可以进行多模式匹配，在论文查重等实际应用中一般都是使用此算法。

首先计算子串的HASH值，之后分别取原字符串中子串长度的字符串计算HASH值，比较两者是否相等：如果HASH值不同，则两者必定不匹配，如果相同，由于哈希冲突存在，也需要按照BF算法再次判定。

按照此例子，首先计算子串“DEF”HASH值为Hd，之后从原字符串中依次取长度为3的字符串“ABC”、“BCD”、“CDE”、“DEF”计算HASH值，分别为Ha、Hb、Hc、Hd，当Hd相等时，仍然要比较一次子串“DEF”和原字符串“DEF”是否一致。

时间复杂度：最坏情况：O（MN），最好情况：O（m+n）

3. KMP算法

我们来观察一下朴素的字符串匹配算法的操作过程。如下图（a）中所描述，在模式 P = ababaca 和文本 T 的匹配过程中，模板的一个特定位移 s，q = 5 个字符已经匹配成功，但模式 P 的第 6 个字符不能与相应的文本字符匹配。

此时，q 个字符已经匹配成功的信息确定了相应的文本字符，而知道这 q 个文本字符，就使我们能够立即确定某些位移是非法的。例如上图（a）中，我们可以判断位移 s+1 是非法的，因为模式 P 的第一个字符 a 将与模式的第二个字符 b 匹配的文本字符进行匹配，显然是不匹配的。而图（b）中则显示了位移 s’ = s+2 处，使模式 P 的前三个字符和相应的三个文本字符对齐后必定会匹配。KMP 算法的基本思路就是设法利用这些已知信息，不要把 “搜索位置” 移回已经比较过的位置，而是继续把它向后面移，这样就提高了匹配效率。

怎么做到利用这些已知信息呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。
首先，要了解两个概念：“前缀"和"后缀”。 "前缀"指除了最后一个字符以外，一个字符串的全部头部组合；"后缀"指除了第一个字符以外，一个字符串的全部尾部组合。

"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。以"ABCDABD"为例，

"A"的前缀和后缀都为空集，共有元素的长度为0；

　"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

　"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

　"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

　"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，“ABCDAB"之中有两个"AB”，那么它的"部分匹配值"就是2（"AB"的长度）。搜索词移动的时候，第一个"AB"向后移动4位（字符串长度-部分匹配值），就可以来到第二个"AB"的位置。

package com.wuyi.notecode;

public class KMP {

    private int[] next;

    public int KMP(String T, String P){
        // 先构造 next 数组
        createNext(P);

        for(int i = 0, j = 0; i < T.length();){
            if (j == P.length() - 1)
                return i - j;

            if (j == 0 || T.charAt(i) == P.charAt(j)){
                i++;
                j++;
            } else {
                j = next[j];
            }
        }
        return -1;
    }

    private void createNext(String P) {
        next = new int[P.length()];
        next[0] = 0;

        for (int i = 1, j = 0;i < P.length();){
            if (j == 0 || P.charAt(i - 1) == P.charAt(j - 1)){
                //j - 1 代表前缀的最后一个索引，i - 1 代表后缀的最后一个索引
                next[i] = j;
                i++;
                j++;
            } else {
                // 若字符不相等，则 j 值回溯
                j = next[j];
            }
        }
    }

    public static void main(String[] args) {
        KMP kmp = new KMP();
        int res = kmp.KMP("baabcabxaababaaabaab","ababaaaba");
        for (int a : kmp.next){
            System.out.print(a + " ");
        }
        System.out.println("\nres:" + res);
    }
}

注意：

• KMP算法从左向右比较
• KMP算法需要一个时间和空间开销为O（m）的预处理（部分匹配函数）过程
• 匹配查找的时间复杂度为O（n+m）

4. KMP模式匹配算法的改进

  它是在计算 next 值的同时，如果a位字符与 next[i] 值指向对的b位字符相等，则该a位的 next[i] 就指向 b 位的 next[i] 值，如果不等，则该 a 位的 next[i] 值就是它自己 a 位的 next[i] 值。

package com.wuyi.notecode;

public class KMP {

    private int[] next;

    public int KMP(String T, String P){
        // 先构造 next 数组
        createNext(P);

        for(int i = 0, j = 0; i < T.length();){
            if (j == P.length() - 1)
                return i - j;

            if (j == 0 || T.charAt(i) == P.charAt(j)){
                i++;
                j++;
            } else {
                j = next[j];
            }
        }
        return -1;
    }

    private void createNext(String P) {
        next = new int[P.length()];
        next[0] = 0;

        for (int i = 1, j = 0;i < P.length();){
            if (j == 0 || P.charAt(i - 1) == P.charAt(j - 1)){
                //j - 1 代表前缀的最后一个索引，i - 1 代表后缀的最后一个索引
                //next[i] = j;
                if (P.charAt(i) != P.charAt(j))
                    next[i] = j;
                else
                    next[i] = next[j];
                i++;
                j++;
            } else {
                // 若字符不相等，则 j 值回溯
                j = next[j];
            }
        }
    }

    public static void main(String[] args) {
        KMP kmp = new KMP();
        int res = kmp.KMP("baabcabxaababaaabaab","abaaba");
        for (int a : kmp.next){
            System.out.print(a + " ");
        }
        System.out.println("\nres:" + res);
    }
}