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

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;
    }
}

笔记

1. 要考虑的细节较多
2. 匹配成功意味着:str遍历到末尾,同时pattern也遍历到末尾; 但是并不意味着pattern的最后一个char和str的最后一个char匹配
3. 在考虑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)
4. pattern一定会遍历完, 但str不一定会
5. 只有pattern遍历完了才触发递归终止条件(这一点跟链表中处理节点的思想有些类似, while循环中,也是处理到链表的最后一个,即while(pCurr != null)), 遍历完意味着当前的j==pattern.length

思路

递归终止条件:

1. 当i == str.length && j == pattern.length时, 匹配成功, 返回true
2. 当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] !&#