dfa转正则表达式_dfa转正则表达式_正则表达式, NFA, DFA, AC多模匹配算法(转) | 果子DO IT...

正则表达式引擎所使用的两种基本技术:非确定型有穷自动机(NFA)和确定型有穷自动机(DFA)。

NFA是基于表达式的(Regex-Directed),去匹对相配文档(文档作为有穷字母表Σ),而DFA是基于文本的(Text-Directed),去匹对相配正则表达式。

目前的主流正则引擎又分为3类:一、DFA,二、传统型NFA,三、POSIX NFA。

DFA:

DFA 引擎在线性时状态下执行,因为它们不要求回溯(并因此它们永远不测试相同的字符两次)。DFA 引擎还可以确保匹配最长的可能的字符串。但是,因为 DFA 引擎只包含有限的状态,所以它不能匹配具有反向引用的模式;并且因为它不构造显示扩展,所以它不可以捕获子表达式。

NFA:

传统的 NFA 引擎运行所谓的“贪婪的”匹配回溯算法,以指定顺序测试正则表达式的所有可能的扩展并接受第一个匹配项。因为传统的 NFA 构造正则表达式的特定扩展以获得成功的匹配,所以它可以捕获子表达式匹配和匹配的反向引用。?但是,因为传统的 NFA 回溯,所以它可以访问完全相同的状态多次(如果通过不同的路径到达该状态)。因此,在最坏情况下,它的执行速度可能非常慢。因为传统的 NFA 接受它找到的第一个匹配,所以它还可能会导致其他(可能更长)匹配未被发现。

NFA最重要的部分:回溯(backtracking)。回溯就像是在道路的每个分岔口留下一小堆面包屑。如果走了死路,就可以照原路返回,直到遇见面包屑标示的尚未尝试过的道路。如果那条路也走不通,你可以继续返回,找到下一堆面包屑,如此重复,直到找到出路,或者走完所有没有尝试过的路。

POSIX NFA:

POSIX NFA 引擎与传统的 NFA 引擎类似,不同的一点在于:在它们可以确保已找到了可能的最长的匹配之前,它们将继续回溯。因此,POSIX NFA 引擎的速度慢于传统的 NFA 引擎;并且在使用 POSIX NFA 时,您恐怕不会愿意在更改回溯搜索的顺序的情况下来支持较短的匹配搜索,而非较长的匹配搜索。

DFA与NFA对比:

1. DFA对于文本串里的每一个字符只需扫描一次,比较快,但特性较少;

NFA要翻来覆去吃字符、吐字符,速度慢,但是特性丰富,所以反而应用广泛。

当今主要的正则表达式引擎,如Perl、Ruby、Python的re模块、Java和.NET的regex库,都是NFA的。

2. 只有NFA支持lazy、backtracking、backreference,NFA缺省应用greedy模式,NFA可能会陷入递归险境导致性能极差。

DFA只包含有穷状态,匹对相配过程中无法捕获子表达式(分组)的匹对相配结果,因此也无法支持backreference。

DFA不能支持捕获括号和反向引用。

POSIX NFA会继续尝试backtracking,以试图像DFA相同找到最长左子正则式。因此POSIX NFA速度更慢。

3. NFA是最左子式匹配,而DFA是最长左子式匹配。

4. NFA的编译过程通常要快一些,需要的内存也更少一些。

对于“正常”情况下的简单文本匹配测试,两种引擎的速度差不多。

一般来说,DFA的速度与正则表达式无关,而NFA中两者直接相关。

5. 对正则表达式依赖性较量强的操作系统(大量应用正则做搜索匹对相配),最好完全把握NFA->DFA算法,充分理解所应用的正则表达式引擎的思想和特性。--- 使用AC多模匹配算法来进行转换?参见snort软件。

使用范围:

目前使用DFA引擎的程序主要有:awk,egrep,flex,lex,MySQL,Procmail等;

使用传统型NFA引擎的程序主要有:GNU Emacs,Java,ergp,less,more,.NET语言,PCRE library,Perl,PHP,Python,Ruby,sed,vi;

使用POSIX NFA引擎的程序主要有:mawk,Mortice Kern Systems’ utilities,GNU Emacs(使用时可以明确指定);

也有使用DFA/NFA混合的引擎:GNU awk,GNU grep/egrep,Tcl。GNU grep采取了一种简单但有效的策略。它尽可能多地使用DFA,在需要反向引用的时候,才切换到NFA。GNU awk的办法也差不多——在进行“是否匹配”的检查时,它采用GNU grep的DFA引擎,如果需要知道具体的匹配文本的内容,就采用不同的引擎。这里的“不同的引擎”就是NFA,利用自己的gensub函数,GNU awk能够很方便地提供捕获括号。

引擎库:

PCRE(Perl Compatible Regular Expressions)是一个Perl库,包括 perl 兼容的正规表达式库。

boost::regex

PCRE是一个轻量级的函数库,比Boost之中的正则表达式库小得多。PCRE十分易用,同时功能也很强大,性能超过了POSIX正则表达式库和一些经典的正则表达式库。

和Boost正则表达式库的比较显示,双方的性能相差无几,PCRE在匹配简单字符串时更快,Boost则在匹配较长字符串时胜出。PCRE被广泛使用在许多开源软件之中,最著名的莫过于Apache HTTP服务器和PHP脚本语言、R脚本语言,此外,正如从其名字所能看到的,PCRE也是perl语言的缺省正则库。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 正则表达式转换NFA(非确定有限自动机)可以通过构造Thompson算法实现。代码示例如下: ```python # 定义NFA状态和边的类 class NFAState: def __init__(self, label=None): self.label = label self.transitions = [] # 定义NFA类 class NFA: def __init__(self, start_state, accept_states): self.start_state = start_state self.accept_states = accept_states def add_transition(self, state1, input, state2): state1.transitions.append((input, state2)) # 正则表达式NFA的函数 def regex_to_nfa(regex): stack = [] for char in regex: if char == '*': # 闭包操作 nfa = stack.pop() accept_state = NFAState() nfa.add_transition(accept_state, None, nfa.start_state) nfa.add_transition(accept_state, None, accept_state) stack.append(NFA(accept_state, [accept_state])) elif char == '|': # 或操作 nfa2 = stack.pop() nfa1 = stack.pop() start_state = NFAState() accept_state = NFAState() start_state.transitions.append((None, nfa1.start_state)) start_state.transitions.append((None, nfa2.start_state)) nfa1.accept_states[0].transitions.append((None, accept_state)) nfa2.accept_states[0].transitions.append((None, accept_state)) stack.append(NFA(start_state, [accept_state])) elif char == '.': # 连接操作 nfa2 = stack.pop() nfa1 = stack.pop() nfa1.accept_states[0].transitions.append((None, nfa2.start_state)) stack.append(NFA(nfa1.start_state, nfa2.accept_states)) else: # 创建单个字符的NFA accept_state = NFAState() start_state = NFAState() start_state.transitions.append((char, accept_state)) stack.append(NFA(start_state, [accept_state])) return stack.pop() ``` NFA转换DFA可以使用子集构造算法实现。代码示例如下: ```python # 定义DFA状态和边的类 class DFAState: def __init__(self, label=None): self.label = label self.transitions = {} # 定义DFA类 class DFA: def __init__(self, start_state, accept_states): self.start_state = start_state self.accept_states = accept_states def add_transition(self, state1, input, state2): state1.transitions[input] = state2 # NFADFA的函数 def nfa_to_dfa(nfa): start_state = DFAState(nfa.start_state.label) dfa_states = [start_state] unmarked_states = [start_state] while unmarked_states: dfa_state = unmarked_states.pop(0) transitions = {} for nfa_state in get_nfa_states(dfa_state, nfa): for transition in nfa_state.transitions: input_symbol = transition[0] next_nfa_state = transition[1] if input_symbol not in transitions: transitions[input_symbol] = set() transitions[input_symbol].add(next_nfa_state) for input_symbol, next_state_states in transitions.items(): next_state_label = ",".join(sorted([n.label for n in next_state_states])) next_state = get_or_create_dfa_state(next_state_label, dfa_states) dfa_state.transitions[input_symbol] = next_state if next_state not in dfa_states: dfa_states.append(next_state) unmarked_states.append(next_state) accept_states = [s for s in dfa_states if nfa.accept_states[0].label in s.label.split(",")] return DFA(start_state, accept_states) # 获取NFA状态的ε闭包 def get_nfa_states(dfa_state, nfa): nfa_states = [] def get_nfa_states_recursive(nfa_state): nfa_states.append(nfa_state) for transition in nfa_state.transitions: input_symbol = transition[0] next_nfa_state = transition[1] if input_symbol is None and next_nfa_state not in nfa_states: get_nfa_states_recursive(next_nfa_state) for nfa_state_label in dfa_state.label.split(","): nfa_state = get_nfa_state_by_label(nfa_state_label, nfa) get_nfa_states_recursive(nfa_state) return nfa_states # 根据NFA状态标签获取NFA状态 def get_nfa_state_by_label(label, nfa): for state in nfa.accept_states: if state.label == label: return state if nfa.start_state.label == label: return nfa.start_state # 根据DFA状态标签获取DFA状态,如果不存在则创建 def get_or_create_dfa_state(label, dfa_states): for state in dfa_states: if state.label == label: return state return DFAState(label) ``` 以上就是将正则表达式转换NFA,以及将NFA转换DFA的代码示例。 ### 回答2: 正则表达式NFA主要包括两个步骤:正则表达式后缀表达式和后缀表达式NFA。 首先,将给定的正则表达式转换为后缀表达式。可以通过使用栈和运算符优先级来实现。遍历正则表达式的每个字符,如果是操作数,则直接输出到后缀表达式。如果是运算符,则根据优先级进行相应的操作,将栈中优先级大于或等于当前运算符的运算符输出到后缀表达式,再将当前运算符压入栈。当所有字符都被处理完后,将栈中剩余的运算符依次输出到后缀表达式中。 然后,根据后缀表达式构建对应的NFA。可以使用Thompson算法来实现此过程。首先,创建一个空的NFA栈。然后,遍历后缀表达式的每个字符。如果是操作符,如'a'、'b',则创建一个新的NFA,其中有两个状态,一个初始状态和一个接受状态,通过一条连接状态的边进行连接,并将该NFA压入NFA栈。如果是运算符,如'|'、'.'、'*',则从NFA栈中弹出对应的NFA,并根据运算符创建新的NFA,并将该NFA压入NFA栈。 最后,将得到的NFA转换DFA。可以使用子集构造算法来实现此过程。首先,将NFA的初始状态作为DFA的初始状态,并计算该状态的ε-闭包。然后,将ε-闭包作为DFA的一个状态,如果该状态中包含NFA的接受状态,则将该状态标记为接受状态。接着,对于每个输入符号,计算该输入符号在当前状态下,通过ε-闭包能够到达的NFA状态,并将其作为DFA的一个新状态。重复以上步骤,直到所有的DFA状态都被生成。最终得到的DFA即为所求。 以上是正则表达式转换NFA转换DFA的基本过程。可以根据具体的编程语言和数据结构进行具体的实现。 ### 回答3: 正则表达式NFA(Nondeterministic Finite Automaton)的过程可以通过使用Thompson算法来实现,以下是一个简单的Python代码示例: ```python class State: def __init__(self, label=None): self.label = label self.edges = [] class NFA: def __init__(self, start=None, end=None): self.start = start self.end = end def regex_to_nfa(regex): stack = [] for char in regex: if char == '.': nfa2 = stack.pop() nfa1 = stack.pop() nfa1.end.edges.append(nfa2.start) stack.append(NFA(nfa1.start, nfa2.end)) elif char == '|': nfa2 = stack.pop() nfa1 = stack.pop() start = State() start.edges.extend([nfa1.start, nfa2.start]) end = State() nfa1.end.edges.append(end) nfa2.end.edges.append(end) stack.append(NFA(start, end)) elif char == '*': nfa = stack.pop() start = State() end = State() start.edges.extend([nfa.start, end]) nfa.end.edges.extend([nfa.start, end]) stack.append(NFA(start, end)) else: start = State() end = State() start.edges.append(end) stack.append(NFA(start, end)) return stack.pop() def nfa_to_dfa(nfa): dfa_start = State() dfa = NFA(dfa_start) dfa_states = [dfa_start] state_map = {} state_queue = [dfa_start] while len(state_queue) > 0: current_state = state_queue.pop(0) state_map[current_state] = {} for char in nfa.alphabet: new_state = State() state_map[current_state][char] = new_state for nfa_state in current_state: if nfa_state.label == char: new_state.append(nfa_state.edges) for edge in nfa_state.edges: if edge not in dfa_states: state_queue.append(edge) dfa_states.append(edge) return dfa regex = "(ab)*c" nfa = regex_to_nfa(regex) dfa = nfa_to_dfa(nfa) ``` 以上代码实现了将正则表达式化为NFA,以及将NFA化为DFA的过程。在这个示例中,我们使用Thompson算法正则表达式转换NFA,并使用子集构造法将NFA转换DFA。最终得到的DFA可以用于模式匹配和字符串匹配等应用。该示例代码仅为简化版本,实际实现中可能会有更多的细节和优化。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值