【剑指offer】面试题19：正则表达式匹配

完整代码地址

完整代码地址

题目

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

思路

正则表达式中有三种情况：
a.普通字符
b.字符’.’
c.普通字符或’.’ + 字符’*’

碰到情况a、b都直接对比可以匹配，
难点在于处理情况c
情况c可以分两种子情况处理：
c1.字符串的首字母与模式的首字母不匹配，模式直接右移两格（相当于’*’前面的字符出现了0次）
c2.字符串的首字母与模式的首字母匹配，则：
　　字符串右移一格，模式不移动（’*’前面的字符出现了不止一次）
　　或字符串右移一格，模式右移两格（’*’前面的字符出现了刚好一次）
　　或字符串不移动，模式右移两格（’*’前面的字符出现了0次）

当字符串和模式同时走到结尾+1的位置，则表示匹配
当字符串走到结尾+1的位置，模式还没走到结尾+1的位置，还要继续匹配（因为模式后面可能还有a*b*可以匹配0个字符串）
当字符串还没走到结尾+1的位置，模式走到结尾+1的位置，则表示不匹配

代码

public class _19_RegularExpressionsMatching {

    public boolean match(char[] str, char[] pattern) {
        if(str == null || pattern == null)
            return false;

        return match(str, 0, pattern, 0);
    }

    private boolean match(char[] str, int strIndex, char[] pattern, int patternIndex) {
        if(strIndex == str.length && patternIndex == pattern.length)
            return true;
        if(patternIndex == pattern.length)
            return false;

        int patternNextIndex = patternIndex + 1;

        // 模式下一个字符为'*'
        if(patternNextIndex < pattern.length && pattern[patternNextIndex] == '*') {
            // str已经走到结尾 || str的字母不等于pattern的字母
            if(strIndex == str.length || 
                    (str[strIndex] != pattern[patternIndex] && pattern[patternIndex] != '.')) {
                return match(str, strIndex, pattern, patternIndex + 2);
            }
            else {
                return match(str, strIndex + 1, pattern, patternIndex + 2) ||
                        match(str, strIndex, pattern, patternIndex + 2) ||
                        match(str, strIndex +1, pattern, patternIndex);
            }
        }
        // 模式下一个字符不为'*' && str走到了结尾 
        else if(strIndex == str.length)
            return false;
        else if(str[strIndex] == pattern[patternIndex] || pattern[patternIndex] == '.')
            return match(str, strIndex + 1, pattern, patternIndex + 1);

        return false;
    }

}

测试

public static void main(String[] args) {
    test1();
    test2();
    test3();
    test4();
}

/**
 * 功能测试
 * 0. 没有'.'和'*'
 * 1. '.'
 * 2. '.' + '*'
 * 3. '*'匹配0次
 * 4. '*'匹配多次
 * 5. '*'匹配一次
 */
private static void test1() {
    _19_RegularExpressionsMatching rem = new _19_RegularExpressionsMatching();
    boolean b = rem.match(new char[] {'a','a','b','c'}, new char[] {'a','a','b','c'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','.','.','.'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','.','*'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'a','b'}, new char[] {'a','a','*','b'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'a','b'}, new char[] {'a','b', '*'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','*','b'});
    MyTest.equal(b, true);
    System.out.println("====================================================");
}

/**
 * 功能测试
 * 0. 没有'.'和'*'
 * 1. '.'
 * 2. '.' + '*'
 * 3. '*'匹配0次
 * 4. '*'匹配多次
 * 5. '*'匹配一次
 */
private static void test2() {
    _19_RegularExpressionsMatching rem = new _19_RegularExpressionsMatching();
    boolean b = rem.match(new char[] {'a','a','b','c'}, new char[] {'a','a','b'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','.','.'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','.','*','c'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'a','b'}, new char[] {'a','a','*'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'a','b'}, new char[] {'a','b', '*','c'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'a','a','a','b'}, new char[] {'a','*'});
    MyTest.equal(b, false);
    System.out.println("====================================================");
}

/**
 * 边界测试
 * 1. '1' - '1'
 * 2. '1' - '.'
 * 3. '1' - '1','*'
 * 4. '1' - '.','*'
 */
private static void test3() {
    _19_RegularExpressionsMatching rem = new _19_RegularExpressionsMatching();
    boolean b = rem.match(new char[] {'1'}, new char[] {'1'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'1'}, new char[] {'.'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'1'}, new char[] {'1','*'});
    MyTest.equal(b, true);

    b = rem.match(new char[] {'1'}, new char[] {'.','*'});
    MyTest.equal(b, true);
    System.out.println("====================================================");
}

/**
 * 极端测试
 */
private static void test4() {
    _19_RegularExpressionsMatching rem = new _19_RegularExpressionsMatching();
    boolean b = rem.match(null, new char[] {'1'});
    MyTest.equal(b, false);

    b = rem.match(new char[] {'1'}, null);
    MyTest.equal(b, false);

    b = rem.match(null, null);
    MyTest.equal(b, false);
}