第19题:正则表达式匹配

题目描述

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

 

 

考点:

正则表达式

递归

字符串

 

思路:

bool match(char* str,char* pattern):

1.str||pattern为nullptr,返回false;

2.进入matchCore函数

 

bool matchCore(char* str,char* pattern):

1.都是结束符,返回true;

2.模式为结束符,字符串不是,返回false;

3. 如果*(pattern + 1) == '*'时,有两种情况:

3.1   如果 *str 和 *前面的字符 *pattern相匹配,  有三种匹配方式:

3.1.1  直接无视*,即 *前面的字符 重复0次,str,pattern+2,直接进入下一机制

3.1.2  *前面的字符 重复1次,str+1,pattern+2 ,进入下一机制

3.1.3  *前面的字符 重复(1+n)次,str+1,pattern,留在这个机制

3.2 否则,str第一个字符 *str 和 *前面的字符 *pattern 不匹配,

直接无视*,重复零次,str ,pattern+2,直接进入下一机制

4.检查两个字符是否匹配:

4.1 如果*pattern == '.' && *str != '\0', 匹配  。

4.2 或者,如果*str == *pattern,匹配。

 当模式和字符串的字符相匹配的时候,就匹配后面的字符。str+1,pattern+1 

 

第一遍

bool matchCore(const char* str, const char* pattern);

bool match(const char* str, const char* pattern)
{
    //1.如果模式或者字符串其中有nullptr,返回假
    if(str == nullptr || pattern == nullptr)
        return false;
    //2.开始递归匹配
    return matchCore(str, pattern);
}

bool matchCore(const char* str, const char* pattern)
{
	//1.递归结束条件:模式和字符串都匹配到了结束,返回真
	if (*str == '\0'&&*pattern == '\0')
		return true;
	//2.递归结束条件:如果模式先结束,字符串还没结束,返回假
	if (*str != '\0'&&*pattern == '\0')
		return false;

	//3.先判断pattern 的下一个字符是否为 *, 如果是,则2种情况,4种匹配方法
	if (*(pattern + 1) == '*')
	{
		//3.1 情况一:当*str与*pattern 匹配 时,有3种匹配方法
		if (*str == *pattern || *pattern == '.'&&*str != '\0')
			//3.1.1 无视 * ,*重复0次,进入下一机制 
			return matchCore(str, pattern + 2) ||
			//3.1.2 *重复1次,进入下一机制 
			matchCore(str + 1, pattern + 2) ||
			//3.1.3 *重复多次,留在这一机制 
			matchCore(str + 1, pattern);
		//3.2 情况二:当*str与*pattern 不匹配 时,无视 * ,*重复0次,进入下一机制 
		else
			return matchCore(str, pattern + 2);

	}

	//4. 直接匹配,如果两个相等,就匹配下一个
	if (*str == *pattern || *pattern == '.'&&*str != '\0')
		return matchCore(str+1,pattern+1);

	//5. 如果两个字符不匹配,就返回假
	return false;
}

 第二遍

 注意——>>  

1. if(*str==*pattern||(*str!='\0'&&*pattern=='.'))//后面的要加括号

2. 

//2.递归结束条件 失败:pattern先结束,字符串还没结束,返回假
        if(*str!='\0'&&*pattern=='\0')
            return false;

匹配是指 字符串的所有字符匹配整个模式。只存在模式比字符串长的情况,因为模式中有*可以无视。

所以不能写 

 if(*str=='\0'&&*pattern!='\0')
            return false;

 

class Solution {
public:
    bool matchCore(char* str,char* pattern)
    {
        //1.递归结束条件 成功:str和pattern都匹配到结束符,返回真
        if(*str=='\0'&&*pattern=='\0')
            return true;
        //2.递归结束条件 失败:pattern先结束,字符串还没结束,返回假
        if(*str!='\0'&&*pattern=='\0')
            return false;
        
        //3.判断模式下一个字符 是*
        if(*(pattern+1)=='*')
        {
            //3.1 情况一:如果模式和字符串的字符匹配
            if(*str==*pattern||(*str!='\0'&&*pattern=='.'))//后面的要加括号
                //3.1.1 无视*,直接进入下一机制
                return matchCore(str,pattern+2)
                //3.1.2 *重复一次,进入下一机制
                ||matchCore(str+1,pattern+2)
                //3.1.3 *重复多次,留在这个机制
                ||matchCore(str+1,pattern);
            //3.2 情况二:模式和字符串不匹配,无视*,进入下一个机制
            return matchCore(str,pattern+2);
        }        
        //4.否则,如果当前字符串和模式匹配,就匹配下一个字符
        else if(*str==*pattern||(*str!='\0'&&*pattern=='.'))
            return matchCore(str+1,pattern+1);
        
        //5.如果都不匹配,返回空
        return false;     
            
    }
    
    
    bool match(char* str, char* pattern)
    {
        //1.如果str或者pattern有空指针,返回假
        if(str==nullptr||pattern==nullptr)
            return false;
        
        //2.递归匹配
        return matchCore(str,pattern);
    
    }
    
    
};

网友的

链接:https://www.nowcoder.com/questionTerminal/45327ae22b7b413ea21df13ee7d6429c
来源:牛客网

/*
    解这题需要把题意仔细研究清楚,反正我试了好多次才明白的。
    首先,考虑特殊情况:
         1>两个字符串都为空,返回true
         2>当第一个字符串不空,而第二个字符串空了,返回false(因为这样,就无法
            匹配成功了,而如果第一个字符串空了,第二个字符串非空,还是可能匹配成
            功的,比如第二个字符串是“a*a*a*a*”,由于‘*’之前的元素可以出现0次,
            所以有可能匹配成功)
    之后就开始匹配第一个字符,这里有两种可能:匹配成功或匹配失败。但考虑到pattern
    下一个字符可能是‘*’, 这里我们分两种情况讨论:pattern下一个字符为‘*’或
    不为‘*’:
          1>pattern下一个字符不为‘*’:这种情况比较简单,直接匹配当前字符。如果
            匹配成功,继续匹配下一个;如果匹配失败,直接返回false。注意这里的
            “匹配成功”,除了两个字符相同的情况外,还有一种情况,就是pattern的
            当前字符为‘.’,同时str的当前字符不为‘\0’。
          2>pattern下一个字符为‘*’时,稍微复杂一些,因为‘*’可以代表0个或多个。
            这里把这些情况都考虑到:
               a>当‘*’匹配0个字符时,str当前字符不变,pattern当前字符后移两位,
                跳过这个‘*’符号;
               b>当‘*’匹配1个或多个时,str当前字符移向下一个,pattern当前字符
                不变。(这里匹配1个或多个可以看成一种情况,因为:当匹配一个时,
                由于str移到了下一个字符,而pattern字符不变,就回到了上边的情况a;
                当匹配多于一个字符时,相当于从str的下一个字符继续开始匹配)
    之后再写代码就很简单了。
*/
class Solution {
public:
    bool match(char* str, char* pattern)
    {
        if (*str == '\0' && *pattern == '\0')
            return true;
        if (*str != '\0' && *pattern == '\0')
            return false;
        //if the next character in pattern is not '*'
        if (*(pattern+1) != '*')
        {
            if (*str == *pattern || (*str != '\0' && *pattern == '.'))
                return match(str+1, pattern+1);
            else
                return false;
        }
        //if the next character is '*'
        else
        {
            if (*str == *pattern || (*str != '\0' && *pattern == '.'))
                return match(str, pattern+2) || match(str+1, pattern);
            else
                return match(str, pattern+2);
        }
    }
};

 

posted @ 2019-02-05 14:14 lightmare 阅读(...) 评论(...) 编辑 收藏