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