Question

我最近遇到了一个采访问题，我需要在Java中实现正则表达式匹配而不使用正则表达式匹配。

给出一个输入字符串（s）和一个模式（p），执行常规表达式匹配并支持'。'，'+'，'*'和'？'。

// (pattern, match) --> bool does it match
// operators:
// . --> any char
// + --> 1 or more of prev char
// * --> 0 or more of prev char
// ? --> 0 or 1 of prev char

// (abc+c, abcccc) --> True
// (abcd*, abc) --> True
// (abc?c, abc) --> True
// (abc.*, abcsdfsf) --> True

我想出了以下仅实现“。”的代码。和“ *”，但无法弄清楚如何实现其他目标：

  public static boolean isMatch(String s, String p) {
    if (p.length() == 0) {
      return s.length() == 0;
    }
    if (p.length() > 1 && p.charAt(1) == '*') { // second char is '*'
      if (isMatch(s, p.substring(2))) {
        return true;
      }
      if (s.length() > 0 && (p.charAt(0) == '.' || s.charAt(0) == p.charAt(0))) {
        return isMatch(s.substring(1), p);
      }
      return false;
    } else { // second char is not '*'
      if (s.length() > 0 && (p.charAt(0) == '.' || s.charAt(0) == p.charAt(0))) {
        return isMatch(s.substring(1), p.substring(1));
      }
      return false;
    }
  }

另外，解决此问题的最佳方法是什么？

Answer 1

这是未经测试的代码。这个想法是我们跟踪字符串和模式中的位置。这不是尝试扩展到完整的RE引擎的好方法（只考虑添加括号会发生什么情况），但在这种情况下很好：

public static boolean isMatch (String p, String s, int pos_p, int pos_s) {
    if (pos_p == p.length()) {
        // We matched the whole pattern.
        return true;
    }
    else if (pos_s == s.length()) {
        // We reached the end of the string without matching.
        return false;
    }
    else if (pos_p == -1) {
        // Do we match the pattern starting next position?
        if (isMatch(p, s, pos_p + 1, pos_s + 1)) {
            return true;
        }
        else {
            // Try to match the pattern starting later.
            return isMatch(p, s, pos_p, pos_s + 1);
        }
    }
    else {
        char thisCharP = p.charAt(pos_p);
        char nextCharP = pos_p + 1 < p.length() ? p.charAt(pos_p + 1) : 'x';

        // Does this character match at this position?
        boolean thisMatch = (thisCharP == s.charAt(pos_s));
        if (thisCharP == '.') {
            thisMatch = true;
        }

        if (nextCharP == '*') {
            // Try matching no times - we don't need thisMatch to be true!
            if (isMatch(p, s, pos_p + 2, pos_s)) {
                return true;
            }
            else {
                // Try matching 1+ times, now thisMatch is required.
                return thisMatch && isMatch(p, s, pos_p, pos_s + 1);
            }
        }
        else if (nextCharP == '+') {
            if (! thisMatch) {
                // to match 1+, we have to match here.
                return false;
            }
            else if (isMatch(p, s, pos_p + 2, pos_s + 1)) {
                // We matched once.
                return true;
            }
            else {
                // Can we match 2+?
                return isMatch(p, s, pos_p, pos_s + 1);
            }
        }
        else if (thisMatch) {
            // Can we match the rest of the pattern?
            return isMatch(p, s, pos_p + 1, pos_s + 1);
        }
        else {
            // We didn't match here, this is a fail.
            return false;
        }
    }
}

public static boolean isMatch (String p, String s) {
    // Can we match starting anywhere?
    return isMatch(p, s, -1, -1);
}

不使用正则表达式的Java中的正则表达式匹配

1 个答案: