剑指offer之正则表达式匹配

题目

思路

1、dp

代码

import java.util.*;
class Solution {
    public boolean isMatch(String A, String B) {
        int n = A.length();
        int m = B.length();
        boolean[][] f = new boolean[n + 1][m + 1];

        for (int i = 0; i <= n; i++) {
            for (int j = 0; j <= m; j++) {
                //分成空正则和非空正则两种
                if (j == 0) {
                    f[i][j] = i == 0;
// boolean f = a==b;意思为boolean f = (a==b)，判断a==b是true还是false,并将该值赋给f
                } else {
                    //非空正则分为两种情况 * 和 非*
                    if (B.charAt(j - 1) != '*') {
                        if (i > 0 && (A.charAt(i - 1) == B.charAt(j - 1) || B.charAt(j - 1) == '.')) {
                            f[i][j] = f[i - 1][j - 1];
                        }
                    } else {
                        //碰到 * 了，分为看和不看两种情况
                        //不看
                        if (j >= 2) {
                            f[i][j] |= f[i][j - 2]; 
                            // a |=b   意思是a= a|b
                        }
                        //看
                        if (i >= 1 && j >= 2 && (A.charAt(i - 1) == B.charAt(j - 2) || B.charAt(j - 2) == '.')) {
                            f[i][j] |= f[i - 1][j];
                        }
                    }
                }
            }
        }
        return f[n][m];
    }
}

2、递归

根据字符串长度进行判断，以正则串的相邻两位字符为单位进行判断，根据正则串中第二位字符是否为'*'选择处理前两位或者一位字符；

 //当字符串为空,1、正则串也为空，则匹配成功；
 //当正则串不为空时，若想匹配成功，则正则串必须为a*b*.*的情况，即索引的第偶数位，必须为'*'，且正则串长度必须为偶数；

当字符串不为空时，将正则串相邻的两位字符作为判断单位；

//对正则串长度进行判断（首先讨论不足两位的情况）

当正则串为空时，匹配必然不成功，直接返回false;

当正则串长度为1时，若字符串长度不为1，则匹配失败；若字符串长度为1，则只有当str.charAt(0) == pattern.charAt(0) || pattern.charAt(0) == '.'字符串字符和正则串中的字符相同或者正则串中为'.'时才能匹配成功，其余均匹配失败；

当正则串长度大于等于2时，分别将正则串中的两个相邻字符记为first ，next，对next是否为*进行讨论：

当next !=*时：此时只需考虑字符串和正则串的第一位字符是否匹配，即字符串字符和正则串中的字符相同或者正则串中为'.'时才能匹配成功，此时继续匹配字符串和正则串的除第一位字符的子串；其余均匹配失败；

当next ==*时：有两种情况：

1、*号前的字符匹配了多次（match(str.substring(1),pattern)），此时正则串不进行子串的截取；或者*号前的字符只匹配了一次，此时正则串中*前的字符连带该*以其作废（ match(str, pattern.substring(2))）；

2、*号前的字符匹配了0次，此时直接将该*号与该*前的字符一起作废，继续匹配（ match(str, pattern.substring(2))）。

import java.util.*;
public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param str string字符串 
     * @param pattern string字符串 
     * @return bool布尔型
     */
    public boolean match (String str, String pattern) {
        // write code here
        //特殊情况
        //当字符串为空,1、正则串也为空，则匹配成功；
        //当正则串不为空时，若想匹配成功，则正则串必须为a*b*.*的情况，即索引的第偶数位，必须为'*'
        //且正则串长度必须为偶数
        if(str.length() == 0){
            if(pattern.length() == 0) return true;
            else{
                if(pattern.length()%2 == 1) return false;
                for (int i = 1;i<pattern.length();i=i+2){
                    if(pattern.charAt(i)!='*') return false;
                }
            }
                return true;
        }
        //字符串不为空时，将正则串两个字符看为一组
        //1、正则串为空
        if(pattern.length() == 0) return false;
        if (pattern.length() == 1){
            if(str.length() !=1) return false;
            else{
                if(str.charAt(0) == pattern.charAt(0) || pattern.charAt(0) == '.')return true;
                else
                    return false;
            }
        }
        char first = pattern.charAt(0), next = pattern.charAt(1);
        if(next != '*') {
            //1.1 两种情况，字符串与正则串有相同字符或正则串为'.';
            if(first == str.charAt(0) || first == '.')
                return match( str.substring(1),pattern.substring(1));
            else 
                return false;
        }else{
            //'*'前的字符出现了多次或一次
            if(first == str.charAt(0) || first == '.') 
                return match(str.substring(1),pattern)|| match(str, pattern.substring(2));
            //该处的正则式-2代表的是*号前面的字符只出现了一次；
            else
                return match(str, pattern.substring(2));
            //该处的正则式-2代表的是*号前面的字符没有出现
        }
    }
}