非确定有限状态自动机的构建(一)——NFA的定义和实现

保留版权,转载需注明出处(http://blog.csdn.net/panjunbiao)。

非确定有限状态自动机(Nondeterministic Finite Automata,NFA)由以下元素组成:

  1. 一个有限的状态集合S
  2. 一个输入符号集合Sigma,并且架设空字符epsilon不属于Sigma
  3. 一个状态迁移函数,对于所给的每一个状态和每一个属于Sigma或{epsilon}的符号,输出迁移状态的集合。
  4. 一个S中的状态s0作为开始状态(初始状态)
  5. S的一个子集F,作为接受状态(结束状态)
例如,我们给定:
  1. S={s0, s1, s2, s3, s4}
  2. Sigma={a, b}
  3. 状态迁移函数T,且T(s0, a} = {s1}, T(s1, a) = {s2}, T(s2, b) = {s3}, T(s3, b) = {s4}
  4. s0为开始状态
  5. {s4}为接受状态
这样我们就得到一个很简单的NFA,它可以用图来表示,如下图图1:


NFA是一个识别器,例如图1所示的NFA,我们从状态s0开始,按顺序输入aabb,在输入第一个符号a之后,状态将从s0迁移到s1,输入第二个符号a之后,状态迁移到s2,输入第三个符号b之后,状态迁移到s3,输入第四个符号b之后,状态迁移到s4,而s4是接收状态,也就是说对我们刚才输入的aabb字符串说yes,表明本NFA识别了所输入的字符串。
所谓非确定,是指在某个状态输入同一个符号,状态可以迁移到不同的下一个状态,例如图2,在s0处输入字符a,状态既可以迁移为s1,也可以迁移为s3,准确的说是状态迁移到了{s1,s3},因此图2所示的NFA能够接受的字符串包括aa和ab。
另外,NFA的特点还在于空符号也能进行状态迁移,例如图3的s0,不需要任何输入字符就可以迁移到s1,因此图3的NFA可以识别的语言为*a*b,即0到任意多个a,接着0到任意多个b。

NFA可以识别的语言与正则表达式所表达的语言是等价的,参考http://en.wikipedia.org/wiki/Nondeterministic_finite_automaton
那么,NFA如何实现呢?我们先来看看NFA状态节点的一种实现:
/*
    This file is one of the component a Context-free Grammar Parser Generator,
    which accept a piece of text as the input, and generates a parser
    for the inputted context-free grammar.
    Copyright (C) 2013, Junbiao Pan (Email: panjunbiao@gmail.com)

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package automata;

import java.util.*;

public class NFAState implements Comparable<NFAState> {
    private static int COUNT = 0;

    //状态标识,每个NFA状态节点都有唯一的数值标识
    private int id;

    public int getId() { return this.id; }

    //在创建NFA状态对象的时候,通过静态变量生成唯一标识
    public NFAState() {
        this.id = COUNT ++;
    }

    //迁移函数,由于迁移函数需要两个输入:当前状态和输入符号,因此在一个状态对象内部,
    //迁移函数都是针对本对象的,只需要输入符号就可以了,这里通过Map接口实现迁移函数
    protected Map<Integer, Set<NFAState>> transition = new HashMap<Integer, Set<NFAState>>();
    public Map<Integer, Set<NFAState>> getTransition() { return this.transition; }

    //空字符迁移函数,即从当前节点经过空字符输入所能够到达的下一个状态节点
    protected Set<NFAState> epsilonTransition = new HashSet<NFAState>();
    public Set<NFAState> getEpsilonTransition() { return this.epsilonTransition; }

    //向迁移函数添加一个映射,不给定下一个状态节点
    public NFAState addTransit(int input) {
        return addTransit(input, new NFAState());
    }

    //向迁移函数添加一个映射,给定下一个状态节点
    public NFAState addTransit(int input, NFAState next) {
        Set<NFAState> states = this.transition.get(input);
        if (states == null) {
            states = new HashSet<NFAState>();
            this.transition.put(input, states);
        }
        states.add(next);
        return next;
    }

    //向迁移函数添加一个映射,不给定下一个状态节点
    public NFAState addTransit(char input) {
        return addTransit(input, new NFAState());
    }

    //向迁移函数添加一个映射,给定下一个状态节点
    //假定我们的上下文无关文法是大小写不敏感的,当输入字符是char类型并且是字母时,
    //生成大写字母和小写字母两个映射
    public NFAState addTransit(char input, NFAState next) {
        if (Character.isLetter(input)) {
            this.addTransit((int) (Character.toUpperCase(input)), next);
            this.addTransit((int)(Character.toLowerCase(input)), next);
            return next;
        }
        this.addTransit((int)input, next);
        return next;
    }

    //添加一个空字符的映射
    public NFAState addTransit(NFAState next) {
        this.epsilonTransition.add(next);
        return next;
    }

    //返回迁移函数
    public Set<NFAState> getTransition(int input) {
        return this.transition.get(input);
    }

}
再来看看NFA的实现:
/*
    This file is one of the component a Context-free Grammar Parser Generator,
    which accept a piece of text as the input, and generates a parser
    for the inputted context-free grammar.
    Copyright (C) 2013, Junbiao Pan (Email: panjunbiao@gmail.com)

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package automata;

import java.util.*;

import abnf.CharVal;
import abnf.NumVal;
import abnf.AbnfParser;
import abnf.RangedNumVal;
import abnf.Repeat;
import abnf.Repetition;
import abnf.Rule;
import abnf.RuleName;

public class NFA {
    //开始状态startState
    private NFAState startState = null;
    public NFAState getStartState() { return startState; }

    //接收状态acceptingStates
    private Set<NFAState> acceptingStates = new HashSet<NFAState>();
    public Set<NFAState> getAcceptingStates() { return acceptingStates; }
    public boolean accept(NFAState state) {
        return this.acceptingStates.contains(state);
    }
    public void addAcceptingState(NFAState state) {
        this.acceptingStates.add(state);
    }

    public NFA() {
        this(new NFAState(), new NFAState());
    }

    public NFA(NFAState startState) {
        this(startState, new NFAState());
    }

    public NFA(NFAState startState, NFAState acceptingState) {
        this.startState = startState;
        this.addAcceptingState(acceptingState);
    }

    //在上面的NFAState类实现中,新的状态节点是在添加迁移映射的过程中生成的,
    //这个过程中NFA并没有介入,因此NFA类不能直接得到状态集S的成员
    //而是需要从状态startState开始,不断迭代找出所有的状态节点
    protected void getStateSet(NFAState current, Set<NFAState> states) {
        if (states.contains(current)) return;
        states.add(current);

        Iterator<NFAState> it;

        it = current.getNextStates().iterator();
        while (it.hasNext()) {
            this.getStateSet(it.next(), states);
        }

        it = current.getEpsilonTransition().iterator();
        while (it.hasNext()) {
            this.getStateSet(it.next(), states);
        }

    }

    public Set<NFAState> getStateSet() {
        Set<NFAState> states = new HashSet<NFAState>();
        this.getStateSet(this.getStartState(), states);
        return states;
    }

}

这样,我们可以从NFA类中获得一个NFA的开始状态startState和接受状态集合acceptingStates,在每一个状态节点NFAState中可以获得状态迁移函数,因此NFA所定义的各个元素都实现了。



发布了40 篇原创文章 · 获赞 16 · 访问量 11万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览