版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/littlehaes/article/details/91411224
welcome to my blog
剑指offer面试题19(java版):正则表达式匹配
题目描述
请实现一个函数用来匹配包括’.‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但是与"aa.a"和"ab*a"均不匹配
笔记
- 要考虑的细节较多
- 匹配成功意味着: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
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;
}
}