【剑指offer】正则表达式匹配（字符串）

最新推荐文章于 2021-04-27 14:02:10 发布

原创最新推荐文章于 2021-04-27 14:02:10 发布 · 992 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#正则表达式 #递归 #模式匹配

剑指offer 专栏收录该内容

67 篇文章

订阅专栏

本文详细解析了正则表达式匹配的递归算法，包括模式中的‘.’和‘*’字符的处理策略，通过具体实例阐述了匹配过程，并提供了C++代码实现。同时，针对递归方法的高复杂度问题，提出了采用动态规划改进的方向。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

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

链接

https://www.nowcoder.com/practice/45327ae22b7b413ea21df13ee7d6429c?tpId=13&tqId=11205&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

思路

首先，这一题肯定是用递归匹配，然后，需要将把思路清晰化。
主要分为两种情况：

1、模式中的第二个字符不是 * 时，要么字符串为一个字符 ch，模式也是 ch，或者模式是 . ，这样才能匹配成功，从而递归匹配字符串的下一个和模式的下一个。否则不匹配，直接 return false。

2、模式中的第二个字符是 * 时，需要分多种情况讨论。

如果当前字符可以匹配，只要有一种以下情况满足则匹配成功。
后面跟 * 的字母不出现，直接跳过，相当于在本状态下匹配 0 次，进入到下一个状态，即字符串位置不变，模式串+2
后面跟 * 的字母出现，匹配完该字母后，字符串+1，模式串+2
后面跟 * 的字母出现，匹配玩该字母后，接着需要判断该字母是否出现多次，字符串+1，模式串位置不变
如果当前字符不可以匹配，则只有一种情况，就是该字符一次都没有出现过，接下来判断，字符串位置不变，模式串+2，即上一种情况的第一种

代码

class Solution {
public:
    bool match(char* str, char* pattern)
    {
        if(str == NULL || pattern == NULL){
            return false;
        }
        return matchCore(str, pattern);
    }
    bool matchCore(char* str, char* pattern){
        if(*str == '\0' && *pattern == '\0'){
            return true;
        }
        if(*str != '\0' && *pattern == '\0'){
            return false;
        }
        if(*(pattern+1) == '*'){
            if(*str == *pattern ||(*pattern == '.' && *str != '\0')){
                return matchCore(str+1, pattern) || matchCore(str, pattern+2) || matchCore(str+1, pattern+2);
            }
            else{
                return matchCore(str, pattern+2);
            }
        }
        if(*str == *pattern ||(*pattern == '.' && *str != '\0')){
            return matchCore(str+1, pattern+1);
        }
        return false;
    }
};

这种递归的做法复杂度太高，对于牛客网给出的剑指offer的题是可以通过的，但是对于Leetcode上给出的用例，则因为复杂度太高而无法在常规时间内得到解。
提交leetcode代码如下，提交剑指offer题可过，leetcode特殊用例超时，需要采用动态规划的方式来达到以空间换时间的效果。见另一篇博客：https://blog.youkuaiyun.com/u013095333/article/details/90756943
特殊用例：

s = "aaaaaaaaaaaaab"
p = "a*a*a*a*a*a*a*a*a*a*c"

class Solution {
public:
    bool match(char* str, char* pattern)
    {
        if(str == NULL || pattern == NULL){
            return false;
        }
        string s = str;
        string p = pattern;
        return isMatched(s, 0, p, 0);
    }
   bool isMatched(string s, int sindex, string p, int pindex){
    	if(sindex == s.length() && pindex == p.length()){
    		return true;
    	}
    	else if(sindex == s.length() && pindex != p.length()){
    		if(pindex < p.length() - 1 && p[pindex+1] == '*'){
    			return isMatched(s, sindex, p, pindex+2);
    		}
    		return false;
    	}
    	else if(sindex != s.length() && pindex == p.length()){
    		return false;
    	}
    	else{
    		if((pindex < p.length() - 1 && p[pindex+1] != '*') || pindex == p.length() - 1){
    			if(s[sindex] == p[pindex] || p[pindex] == '.'){
    				return isMatched(s, sindex+1, p, pindex+1);
    			}
    			else{
    				return false;
    			}
    		}
    		else if(pindex < p.length() - 1 && p[pindex+1] == '*'){
    			if(s[sindex] == p[pindex] || p[pindex] == '.'){
    				return isMatched(s, sindex+1, p, pindex+2) || isMatched(s, sindex+1, p, pindex) || isMatched(s, sindex, p, pindex+2);
    			}
    			else{
    				return isMatched(s, sindex, p, pindex+2);
    			}
    		}
    	}
    	return false;
    }
};