《算法》-字符串[正则表达式]

正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。

正则表达式描述了一种字符串匹配的模式（pattern），可以用来检查一个字符串是否含有满足该pattern的子串，正则表达式典型应用如下图：

常见的表示前面的符号重复0或多次，比如AB表示的字符串由一个A和0个或多个B组成。

|表示或操作，如AB|CD,可以表示字符串AB或者CD

()可以改变默认的优先级，举例如下：


每个正则表达式都对应一个非确定有限状态自动机(NFA)，根据正则表达式查找字符串首先将其转化成对应的NFA，然后在文本上模拟NFA的运行，看文本是否与该NFA对应的正则表达式匹配

//grep命令简单实现

public class GREP {
public static void main(String[] args) {
String regexp = "(.*" + args[0] + ".*)";

//根据正则表达式构造NFA

NFA nfa = new NFA(regexp);

while (StdIn.hasNextLine()) {
String line = StdIn.readLine();

//在文本line上模拟NFA的运行看是否与对应的正则表达式匹配

if (nfa.recognizes(line)) {
StdOut.println(line);

}

}

}

}

//NFA实现

public class NFA {
private Digraph graph; // digraph of epsilon transitions

private String regexp; // regular expression

private final int m; // number of characters in regular expression

根据正则表达式构造NFA

长度为M的正则表达式中的每个字符在NFA中都对应一个状态，NFA的起始状态为0,并有一个虚拟的接受状态M,如下图

字母表中的字符对应的状态都有一条从它指出的边，如图中黑色的边(A,B,A,C,D水平指出的边)

元字符(,),|,*对应的状态至少有一条指出的边，如图中红色的边

一个状态可以有多条指出的边，但只能有一条黑色的边

约定模式由括号包围,所以NFA第一个状态是(，最后一个状态是)并指向接受状态M

NFA中的状态转换有两种方式，示意图如下：

1.如果当前状态的字符和文本中当前字符匹配，则可以通过黑色的边转换到下一状态，称为匹配转换.

2.自动机可以通过红色的边转换到下一状态而不扫描文本中的任何字符，这种转换称为E-转换.

用char数组re[]保存正则表达式本身，如果re[i]在字母表中，就存在从i到i+1的匹配转换

用有向图G表示所有的E-转换，如上图的NFA对应的有向图含有下面9条边

用栈来处理括号，构造规则如下图

代码如下，结合正则表达式对应的NFA图来看就比较好理解了

public NFA(String regexp) {
this.regexp = regexp;

m = regexp.length();

Stack<Integer> ops = new Stack<Integer>();

graph = new Digraph(m+1);

for (int i = 0; i < m; i++) {
int lp = i;

if (regexp.charAt(i) == '(' || regexp.charAt(i) == '|')

ops.push(i);

else if (regexp.charAt(i) == ')') {
int or = ops.pop();

// 2-way or operator

if (regexp.charAt(or) == '|') {
lp = ops.pop();

graph.addEdge(lp, or+1);

graph.addEdge(or, i);

}

else if (regexp.charAt(or) == '(')

lp = or;

else assert false;

}

// closure operator (uses 1-character lookahead)

if (i < m-1 && regexp.charAt(i+1) == '*') {
graph.addEdge(lp, i+1);

graph.addEdge(i+1, lp);

}

if (regexp.charAt(i) == '(' || regexp.charAt(i) == '*' || regexp.charAt(i) == ')')

graph.addEdge(i, i+1);

}

if (ops.size() != 0)

throw new IllegalArgumentException("Invalid regular expression");

}

在文本txt上模拟NFA的运行看是否与对应的正则表达式匹配,如果到达了接受状态，则称该NFA识别了这段文本

模拟运行流程如下图

//代码如下

public boolean recognizes(String txt) {
//获取从起始状态0通过E-转换后能够到达的所有状态，存在Bag pc中

//深度优先搜索获取有向图graph中顶点0可达的所有顶点

DirectedDFS dfs = new DirectedDFS(graph, 0);

Bag<Integer> pc = new Bag<Integer>();

for (int v = 0; v < graph.V(); v++)

if (dfs.marked(v)) pc.add(v);

 

// Compute possible NFA states for txt[i+1]

for (int i = 0; i < txt.length(); i++) {
if (txt.charAt(i) == '*' || txt.charAt(i) == '|' || txt.charAt(i) == '(' || txt.charAt(i) == ')')

throw new IllegalArgumentException("text contains the metacharacter '" + txt.charAt(i) + "'");

//

Bag<Integer> match = new Bag<Integer>();

//看Bag pc中是否有与txt[i]匹配的字符，如果有则把匹配后v可达的状态v+1存入Bag match中

for (int v : pc) {
if (v == m) continue;

if ((regexp.charAt(v) == txt.charAt(i)) || regexp.charAt(v) == '.')

match.add(v+1);

}

//再把match中的状态通过E-转换后能够到达的所有状态，存在Bag pc中

dfs = new DirectedDFS(graph, match);

pc = new Bag<Integer>();

for (int v = 0; v < graph.V(); v++)

if (dfs.marked(v)) pc.add(v);

 

// optimization if no states reachable

if (pc.size() == 0) return false;

//用Bag pc继续匹配txt中下一个字符 go for

}

 

// check for accept state

for (int v : pc)

if (v == m) return true;

return false;

}

 

/**

* Unit tests the {@code NFA} data type.

*

* @param args the command-line arguments

*/

public static void main(String[] args) {
String regexp = "(" + args[0] + ")";

String txt = args[1];

NFA nfa = new NFA(regexp);

StdOut.println(nfa.recognizes(txt));

}

 

}