LeetCode – Regular Expression Matching in Java

Implement regular expression matching with support for '.' and '*'.

'.' Matches any single character.
'*' Matches zero or more of the preceding element.

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") return false
isMatch("aa","aa") return true
isMatch("aaa","aa") return false
isMatch("aa", "a*") return true
isMatch("aa", ".*") return true
isMatch("ab", ".*") return true
isMatch("aab", "c*a*b") return true

1. Analysis

First of all, this is one of the most difficulty problems. It is hard to think through all different cases. The problem should be simplified to handle 2 basic cases:

  • the second char of pattern is "*"
  • the second char of pattern is not "*"

For the 1st case, if the first char of pattern is not ".", the first char of pattern and string should be the same. Then continue to match the remaining part.

For the 2nd case, if the first char of pattern is "." or first char of pattern == the first i char of string, continue to match the remaining part.

2. Java Solution 1 (Short)

The following Java solution is accepted.

public class Solution {
    public boolean isMatch(String s, String p) {
 
        if(p.length() == 0)
            return s.length() == 0;
 
        //p's length 1 is special case    
        if(p.length() == 1 || p.charAt(1) != '*'){
            if(s.length() < 1 || (p.charAt(0) != '.' && s.charAt(0) != p.charAt(0)))
                return false;
            return isMatch(s.substring(1), p.substring(1));    
 
        }else{
            int len = s.length();
 
            int i = -1; 
            while(i<len && (i < 0 || p.charAt(0) == '.' || p.charAt(0) == s.charAt(i))){
                if(isMatch(s.substring(i+1), p.substring(2)))
                    return true;
                i++;
            }
            return false;
        } 
    }
}

3. Java Solution 2 (More Readable)

public boolean isMatch(String s, String p) {
	// base case
	if (p.length() == 0) {
		return s.length() == 0;
	}
 
	// special case
	if (p.length() == 1) {
 
		// if the length of s is 0, return false
		if (s.length() < 1) {
			return false;
		}
 
		//if the first does not match, return false
		else if ((p.charAt(0) != s.charAt(0)) && (p.charAt(0) != '.')) {
			return false;
		}
 
		// otherwise, compare the rest of the string of s and p.
		else {
			return isMatch(s.substring(1), p.substring(1));
		}
	}
 
	// case 1: when the second char of p is not '*'
	if (p.charAt(1) != '*') {
		if (s.length() < 1) {
			return false;
		}
		if ((p.charAt(0) != s.charAt(0)) && (p.charAt(0) != '.')) {
			return false;
		} else {
			return isMatch(s.substring(1), p.substring(1));
		}
	}
 
	// case 2: when the second char of p is '*', complex case.
	else {
		//case 2.1: a char & '*' can stand for 0 element
		if (isMatch(s, p.substring(2))) {
			return true;
		}
 
		//case 2.2: a char & '*' can stand for 1 or more preceding element, 
		//so try every sub string
		int i = 0;
		while (i<s.length() && (s.charAt(i)==p.charAt(0) || p.charAt(0)=='.')){
			if (isMatch(s.substring(i + 1), p.substring(2))) {
				return true;
			}
			i++;
		}
		return false;
	}
}
Category >> Algorithms  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
<pre><code> 
String foo = "bar";
</code></pre>
  • JL

    isMatch(String s, int s_pos, String p, int p_pos)

  • Matias SM

    A non-recursive approach. It assumes the existence of an invalid matchingChar which may not be a valid assumption (but could be easily replaced with an optional or null and Character usage).


    boolean isMatch(String str, String pattern) {
    if (str.isEmpty() ^ pattern.isEmpty()) return false;

    boolean isMatchingStar = false;
    char matchingChar = ''; //a non-valid char

    int i = 0;
    int p = 0;
    while (i p && ! isMatchingStar) {
    matchingChar = pattern.charAt(p);
    //may add check for special char for sanity (invalid expression)
    ++p;
    if (pattern.length() > p && pattern.charAt(p) == '*') { //look ahead for *
    isMatchingStar = true;
    ++p;
    }
    } else if (! isMatchingStar) {
    matchingChar = ''; //or some other invalid char
    }
    if (str.charAt(i) == matchingChar || matchingChar == '.') {
    ++i;
    } else {
    if (! isMatchingStar) return false;
    else isMatchingStar = false;
    }
    }

    //we completed the str, need to check if there is still pattern to match
    while (p < pattern.length()) {
    int next = p + 1;
    //if there is a char but no wildcard, pattern not matched
    if (pattern.length() <= next || pattern.charAt(next) != '*')
    return false;
    p = next + 1;
    }
    return true;
    }

    Time complexity O(N), Space O(1)

  • Qiongjie

    I only check the short version of your code. It fails for this case: isMatch(“ab*b”, “ab*bb”);

  • Maggie M’Gill

    Hi,
    Shouldn’t the following be true
    String s = “a”;
    String p = “a*”;
    ?
    According to the given code, it will evaluate to false.

  • Student

    Hi, Can anyone tell me the complexity of this algorithm

  • ww

    s.matches(p);

  • Anton Lisovenko

    That’s not the first time the solution on programcreek is too complicated. Here is the more clear and simple solution:

    http://ideone.com/PYDm0E

  • Jing

    “aab” doesn’t match “c*a*cbaab”. Because ‘*’ means the preceding character occurs 0 or more times, here ‘c’ and ‘a’ occurs 0 time and “c*a*cbaab” equals “cbaab”.

  • Davis Zhong

    So how do you pass in the indices for both strings to isMatch(). The parameters of isMatch are String.

  • Zlatko Stamatov

    When testing the solution I have a problem with this test case:

    assertEquals(true, LeetCode.isMatch(“aab”, “c*a*cbaab”));

    Any ideas on what is the problem?

  • jin

    for those who doesn’t understand this code, maybe this is link helps.

    https://oj.leetcode.com/discuss/9405/the-shortest-ac-code

  • Mangat Rai

    hey!
    Its a bad habit to use substring function in Java. Since Java 7 strings are not indexed. Complexity of substring function has changed from O(1) to O(n) as now Java copies whole string into new one and returns it instead of moving pointers in the string.

    So the complexity of your code has increased n-times. Sadly test cases at leetcode are quite weak to check complexity issues.