剑指offer面试题19(java版):正则表达式匹配

原创

littlehaes 2023-01-18 00:43:54 ©著作权

©著作权归作者所有：来自51CTO博客作者littlehaes的原创作品，请联系作者获取转载授权，否则将追究法律责任

welcome to my blog

剑指offer面试题19(java版):正则表达式匹配

题目描述

请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配

第四次做; 核心: 1)使用.charAt()时得先保证索引不越界, 使用.charAt()时得先保证索引不越界, 使用.charAt()时得先保证索引不越界 2)根据p.charAt(p2+1)是否为’‘分成两种情况讨论, 因为’'直接将这个问题复杂化了!

class Solution {
    public boolean isMatch(String s, String p) {
        //input check
        int n = s.length(), m = p.length();
        if(n==0 && m==0)
            return true;
        if(n!=0 && m==0)
            return false;
        //m!=0
        return core(s, p, 0, 0);
    }
    
    //递归函数逻辑: 判断s[p1]和p[p2]是否匹配(当前条件), 如果匹配则p1,p2继续移动, 如果不匹配则判断p[p2+1]是否是*...(新条件新递归)
    private boolean core(String s, String p, int p1, int p2){
        //base case
        int n = s.length(), m = p.length();
        if (p1 == n && p2 == m)
            return true;
        if (p1 != n && p2 == m)
            return false;
        //here, p2!=m, 也就是p2<m
        boolean flag = false;
        //要保证索引不越界, 才能进行比较
        if (p2 + 1 < m && p.charAt(p2 + 1) == '*') {
            if (p1 < n && (s.charAt(p1) == p.charAt(p2) || p.charAt(p2) == '.')) {
                //可以选择匹配或者不匹配
                flag = core(s, p, p1 + 1, p2) || core(s, p, p1, p2 + 2);
            }
            //p1==n ||  (s.charAt(p1) != p.charAt(p2) && p.charAt(p2)!='.')
            else {
                //只能选择不匹配
                flag = core(s, p, p1, p2 + 2);
            }
        }
        //p2+1==m || p.char(p2)!="*"
        else {
            if (p1 < n && (s.charAt(p1) == p.charAt(p2) || p.charAt(p2) == '.'))
                flag = core(s, p, p1 + 1, p2 + 1);
            else
                flag = false;
        }
        return flag;
    }
}

笔记

要考虑的细节较多
匹配成功意味着:str遍历到末尾,同时pattern也遍历到末尾; 但是并不意味着pattern的最后一个char和str的最后一个char匹配
在考虑str[i]和pattern[j]时, 并不是用if else区分二者是否匹配, 而是用if else区分pattern[j+1]是否为*, 用j+1作为索引时要考虑是否越界(言外之意, j+1不作为索引就不用考虑是否越界, 这一点跟链表的情况有点类似. 使用pCurr.next.val时得先判断pCurr.next是否是null, 如果不使用pCurr.next.val,可以不用判断是否是null)
pattern一定会遍历完, 但str不一定会
只有pattern遍历完了才触发递归终止条件(这一点跟链表中处理节点的思想有些类似, while循环中,也是处理到链表的最后一个,即while(pCurr != null)), 遍历完意味着当前的j==pattern.length

思路

递归终止条件:

当i == str.length && j == pattern.length时, 匹配成功, 返回true
当i != str.length && j == pattern.length时, 匹配失败, 返回false

上面两个条件取并集后是j == pattern.length, 也就是说考虑完了j == pattern.length的情况,在正常执行中要考虑 j != pattern.length

正常执行

考虑当前要比较的str[i]和pattern[j] (回顾笔记3)

当j+1 < pattern.length && pattern[j+1] == '*'时(回顾笔记3), 一共三种情况

str[i]与pattern[j]匹配成功,只匹配一次, 然后i=i+1,j=j+2继续匹配
str[i]与pattern[j]匹配成功,匹配多次, 然后i=i+1, j不变,继续匹配
str[i]与pattern[j]匹配失败, 然后i不变, j=j+2, 继续匹配

上面三种情况综合在一个return语句中, return matchCore(str, i+1, pattern, j) || matchCore(str, i+1, pattern, j+2) || matchCore(str, i, pattern, j+2);
该return语句最厉害的地方在于可以尝试匹配任意次, 从任意次的结果中选取一个合适的结果. 比如可以解决这个匹配问题:aaa与aa*aa

当j+1 >= pattern.length || (j+1 < pattern.length && pattern[j+1] != ‘*’)时, 此时不涉及匹配多个char的问题,就是简单的一对一匹配(仔细体会本条的||)

如果str[i] == pattern[j] || pattern[j] == ‘.’, 表示str[i]与pattern[j]匹配成功, 继续匹配下一个元素
否则返回false

第三次做, input check比较细:要区分str==null和str.length==0的区别; str索引的越界检查; 特例"" “.*” true; 大题思路有了, 但是细节吃的不透, 不容易改成动态规划

/*
按照下一个char是否为"*"分成两类讨论
例子: "",".*"  true
*/
public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        //input check
        if((str==null || str.length==0) && (pattern==null || pattern.length==0))
            return true;
        if(str!=null&&str.length!=0&&(pattern==null || pattern.length==0))
            return false;
        //here, str和pattern都不为空 或者 str为空但是pattern不为空
        return Core(str, pattern, 0, 0);
    }
    public boolean Core(char[] str, char[] pattern, int strIndex, int patternIndex){
        if(patternIndex==pattern.length && strIndex==str.length)
            return true;
        if(patternIndex==pattern.length && strIndex != str.length)
            return false;
        //here, patternIndex!=pattern.length
        boolean res = false;
        if(patternIndex+1<pattern.length && pattern[patternIndex+1]=='*'){
            //match
            if(strIndex<str.length && (pattern[patternIndex]=='.' ||  pattern[patternIndex]==str[strIndex]))
                res = Core(str, pattern, strIndex+1, patternIndex);
            return res || Core(str,pattern, strIndex, patternIndex+2);
        }
        else{//here,要么patternIndex指向最后一个元素, 要么patternIndex+1不指向*
            //match
            if(pattern[patternIndex]=='.' || (strIndex<str.length && pattern[patternIndex]==str[strIndex]))
                return Core(str, pattern, strIndex+1, patternIndex+1);
            //don't match
            else
                return false;
        }
    }
}

第二次做, 按照pattern[p+1]是否为’*'分成两种情况讨论; 还要随时注意str索引的越界检查,以及str.length==0的情况

这是道好题!

/*
核心: 按照pattern[p+1]=='*'和pattern[p+1]!='*'分成两类讨论
格外要注意的地方:s的越界判断; str.length==0时s的越界判断

*/
public class Solution {
    public boolean match(char[] str, char[] pattern)
    {
        if(str==null)
            return false;
        return Core(str, pattern, 0, 0);
    }
    public boolean Core(char[] str, char[] pattern, int s, int p){
        //base case
        if(p==pattern.length && s==str.length)
            return true;
        if(p==pattern.length && s != str.length)
            return false;
        //here, p!=pattern, s没有限制,所以使用s时需要判断是否越界(本题最琐碎的地方,容易错)
        if(p+1==pattern.length || (p+1<pattern.length && pattern[p+1] != '*')){
            if(s<str.length && (str[s] == pattern[p] || pattern[p] == '.') )
                return Core(str, pattern, s+1, p+1);
            return false;
        }
        if(p+1<pattern.length && pattern[p+1] == '*'){
            //(s<str.length && pattern[p] == '.')即使没用到str也要判断s是否越界,防止str.length==0的情况
            if((s<str.length && str[s] == pattern[p]) || (s<str.length && pattern[p] == '.'))
                return Core(str, pattern, s, p+2) || Core(str, pattern, s+1, p);
            return Core(str, pattern, s, p+2);
        }
        return false;
    }
}

public class Solution {
    public static boolean match(char[] str, char[] pattern)
    {
        //input check
        
        // execute
        return matchCore(str, 0, pattern, 0);
    }
    public static boolean matchCore(char[] str, int i, char[] pattern, int j){
        // 递归终止条件
        int strLen = str.length;
        int patternLen = pattern.length;
        if(i == strLen && j == patternLen)
            return true;
        if(i != strLen && j == patternLen)
            return false;
        
        if(i == strLen && j != patternLen){
            if(pattern[patternLen-1]!='*')
                return false;
            for(int t=j+1; t< patternLen; t=t+2){
                if(pattern[t]!='*')
                    return false;
            }
                return true;
        }
        else{ // i != strLen && j != patternLen
            if(j+1 < patternLen && pattern[j+1] == '*'){
                if(str[i] == pattern[j] || pattern[j] == '.')
                    return matchCore(str, i+1, pattern, j) || matchCore(str, i+1, pattern, j+2) || matchCore(str, i, pattern, j+2);
                else{ //str[i] != pattern[j] && pattern[j] != '.'
                    return matchCore(str, i, pattern, j+2);
                    
                }
            }
            else{ // j+1 >= patternLen  或者 pattern[j+1] != '*'
                if(str[i] == pattern[j] || pattern[j] == '.')
                    return matchCore(str, i+1, pattern, j+1);
                else{ // str[i] != pattern[j]
                    return false;
                }
            }
        }
        //return false;
    }
}

进阶的代码

笔记

不管str有没有遍历完, pattern一定会逐个遍历完
要明确如何判断: aa和aa.*.* 这个例子
时刻检查数组不越界
明确: 有*才能跳跃, 没有*则必须对应一致, 否则返回false
有*的情况下什么时候跳跃? pattern[j]与str[i]不匹配,或者i==str.length(也就是str遍历完了,但是pattern还没遍历完)
什么时候能够触发递归终止条件?

public class Solution {
    public static boolean match(char[] str, char[] pattern)
    {
        //input check
        if(str==null || pattern == null)
            throw new RuntimeException("invalid input");
        // execute
        return matchCore(str, 0, pattern, 0);
    }
    public static boolean matchCore(char[] str, int i, char[] pattern, int j){
        // 递归终止条件
        int strLen = str.length;
        int patternLen = pattern.length;
        if(i == strLen && j == patternLen)
            return true;
        if(i != strLen && j == patternLen)
            return false;
        // j != patternLen, 这个条件下对应着 i == strLen(对应数组越界) 和 i != strLen , 下面的语句合并处理了这两个情况
        if(j+1 < patternLen && pattern[j+1] == '*'){
            if( i<strLen && (str[i] == pattern[j] || pattern[j] == '.'))
                // return语句中,从左到右三个语句分别表示: 匹配多个,匹配一个,匹配零个
                return matchCore(str, i+1, pattern, j) || matchCore(str, i+1, pattern, j+2) || matchCore(str, i, pattern, j+2);
            else{ //i >= strLen  或者 (str[i] != pattern[j] && pattern[j] != '.')
                return matchCore(str, i, pattern, j+2);
            }
        }
        else{ // j+1 >= patternLen  或者 (j+1 < patternLen  &&  pattern[j+1] != '*')
            if(i<strLen && (str[i] == pattern[j] || pattern[j] == '.'))
                return matchCore(str, i+1, pattern, j+1);
            else{ // i >= strLen  或者 str[i] != pattern[j]
                return false; // pattern还没遍历完,同时pattern[j+1]不是*, 如果pattern[j]没有对应的匹配项就意味着匹配失败了
            }
        }
        //return false;
    }
}

参考答案, 写的很好

笔记

当模式中的第二个字符不是“*”时：

如果字符串第一个字符和模式中的第一个字符相匹配，那么字符串和模式都后移一个字符，然后匹配剩余的。
如果字符串第一个字符和模式中的第一个字符相不匹配，直接返回false。

而当模式中的第二个字符是“*”时：

如果字符串第一个字符跟模式第一个字符不匹配，则模式后移2个字符，继续匹配。如果字符串第一个字符跟模式第一个字符匹配，可以有3种匹配方式：

模式后移2字符，相当于x*被忽略；
字符串后移1字符，模式后移2字符；
字符串后移1字符，模式不变，即继续匹配字符下一位，因为*可以匹配多位；

public class Solution {
    public boolean match(char[] str, char[] pattern) {
    if (str == null || pattern == null) {
        return false;
    }
    int strIndex = 0;
    int patternIndex = 0;
    return matchCore(str, strIndex, pattern, patternIndex);
}
  
public boolean matchCore(char[] str, int strIndex, char[] pattern, int patternIndex) {
    //有效性检验：str到尾，pattern到尾，匹配成功
    if (strIndex == str.length && patternIndex == pattern.length) {
        return true;
    }
    //pattern先到尾，匹配失败
    if (strIndex != str.length && patternIndex == pattern.length) {
        return false;
    }
    //模式第2个是*，且字符串第1个跟模式第1个匹配,分3种匹配模式；如不匹配，模式后移2位
    if (patternIndex + 1 < pattern.length && pattern[patternIndex + 1] == '*') {
        if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
            return matchCore(str, strIndex, pattern, patternIndex + 2)//模式后移2，视为x*匹配0个字符
                    || matchCore(str, strIndex + 1, pattern, patternIndex + 2)//视为模式匹配1个字符
                    || matchCore(str, strIndex + 1, pattern, patternIndex);//*匹配1个，再匹配str中的下一个
        } else {
            return matchCore(str, strIndex, pattern, patternIndex + 2);
        }
    }
    //模式第2个不是*，且字符串第1个跟模式第1个匹配，则都后移1位，否则直接返回false
    if ((strIndex != str.length && pattern[patternIndex] == str[strIndex]) || (pattern[patternIndex] == '.' && strIndex != str.length)) {
        return matchCore(str, strIndex + 1, pattern, patternIndex + 1);
    }
    return false;
    }
}