对任意给定的NFA M进行确定化操作（附详细注释）

DFA实体类

package Beans;

import java.util.List;

public class DFA {

    private List<Integer> K;    // 状态集

    private char[] letters;     // 字母表

    private String[][] f;       // 转换函数

    private int S;              // 唯一初态

    private List<Integer> Z;    // 终态集

    public List<Integer> getK() {
        return K;
    }

    public void setK(List<Integer> k) {
        K = k;
    }

    public char[] getLetters() {
        return letters;
    }

    public void setLetters(char[] letters) {
        this.letters = letters;
    }

    public String[][] getF() {
        return f;
    }

    public void setF(String[][] f) {
        this.f = f;
    }

    public int getS() {
        return S;
    }

    public void setS(int s) {
        S = s;
    }

    public List<Integer> getZ() {
        return Z;
    }

    public void setZ(List<Integer> z) {
        Z = z;
    }
}

NFA实体类

package Beans;

import java.util.List;

public class NFA {

    private List<Integer> K;    // 状态集

    private char[] letters;     // 字母表

    private String[][] f;       // 转换函数

    private List<Integer> S;    // 初态集

    private List<Integer> Z;    // 终态集

    public List<Integer> getK() {
        return K;
    }

    public void setK(List<Integer> k) {
        K = k;
    }

    public char[] getLetters() {
        return letters;
    }

    public void setLetters(char[] letters) {
        this.letters = letters;
    }

    public String[][] getF() {
        return f;
    }

    public void setF(String[][] f) {
        this.f = f;
    }

    public List<Integer> getS() {
        return S;
    }

    public void setS(List<Integer> s) {
        S = s;
    }

    public List<Integer> getZ() {
        return Z;
    }

    public void setZ(List<Integer> z) {
        Z = z;
    }


}

NFA转换成DFA方法类（NFA2DFA）

package Service;

import Beans.DFA;
import Beans.NFA;

import java.util.*;

public class NFA2DFA {

    /**
     * definite:【子集法】将NFA确定化为DFA
     * @param nfa 输入nfa
     * @return    返回dfa
     *
     * 伪代码逻辑：
     *  DFA状集合C(注：C的每个成员又都是NFA的状态state的集合)
     *  Queue 临时队列queue;
     *  NFA的初态集S(K0)的闭包入队;
     *  while(队不空):
     *      取出当前状态I;
     *      for 每个输入字母 in letters:
     *             nextI = ε-closure(move(I, letter));
     *             if(C 不包含 nextI) :
     *                  则nextI入队
     *
     *  最终的C即为确定化生成的DFA的状态集
     */
    public DFA definite(NFA nfa){
        List<Integer> K0 = nfa.getS();//获取初态集
        char[] letters = nfa.getLetters();//获取字母表
        String[][] f = nfa.getF();//获取转换函数
        List<Integer> Z = nfa.getZ();//获取终态集

        DFA dfa = new DFA(); //new一个DFA对象
        List<Integer> K = new ArrayList<>();             // DFA状态集合(已重命名)
        int k = 0;                                       // 用于DFA状态集的重命名
        List<String[]> listF = new ArrayList<>();        // 用于暂存转换函数f
        List<Integer> listZ = new ArrayList<>();         // 用于暂存终态集Z
        StringBuilder sb = new StringBuilder();          // 用于输出整个子集法的过程

        Set<List<Integer>> set = new HashSet<>();               // 状态集临时集合
        Queue<List<Integer>> queue = new LinkedList<>();        // 状态集临时队列
        Map<List<Integer>, Integer> map = new HashMap<>();      //「状态集」向「命名」的映射

        List<Integer> closure_K = closure(K0, f); //初始状态自身以及自身能通过ε'到达的状态'的集合。
        K.add(k);//将0作为一个状态
        map.put(closure_K, k++);//将能到达的状态放入映射接口
        queue.add(closure_K);//获得的能到达的状态集放入队列
        while(!queue.isEmpty()){
            List<Integer> I = queue.poll();//poll()返回队首元素的同时删除队首元素，队列为空时返回NULL，I为能到达的状态集
            for(char letter : letters){//遍历字母表
                List<Integer> nextI = closure(move(I, letter, f), f);//当前状态集通过某个字母可以转化到的下一状态集（一步转换，没有进行ε-闭包运算）
                //再进行闭包运算
                if(nextI.isEmpty()) continue;//跳出此次循环，执行下一次循环
                if(!containsI(set, nextI)){//如果不包含，则执行
                    nextI.sort(Comparator.comparing(Integer::intValue));//正序排序
                    map.put(nextI, k);
                    K.add(k);
                    if(!Collections.disjoint(nextI, Z)){//检查两个集合是否相交
                        listZ.add(k);//相交的话将k放入暂存的终态集中
                    }
                    set.add(nextI);//放入set中
                    queue.add(nextI);
                    k++;
                }
                System.out.print(I);
                System.out.println(nextI);
                listF.add(new String[]{String.valueOf(map.get(I)), String.valueOf(letter), String.valueOf(map.get(nextI))});
                sb.append(map.get(I)).append(letter).append(map.get(nextI)).append('\n');//保存整个子集法的过程
            }
        }
        System.out.println("重命名后：");
        System.out.println(sb.toString());//输出整个子集法的过程

        // 下面是为了构造出DFA对象
        int len = K.size();
        String[][] f2 = new String[len][len];
        for(String[] tmp : f2){
            Arrays.fill(tmp, "");
        }
        for(String[] arr : listF){
            f2[Integer.parseInt(arr[0])][Integer.parseInt(arr[2])] += arr[1];
        }
        dfa.setK(K);// 状态集
        dfa.setLetters(letters);//字母表
        dfa.setF(f2);//转换函数
        dfa.setS(0);//初态集
        dfa.setZ(listZ);//终态集
        return dfa;
    }

    /**
     * ε-closure闭包运算：某个状态集经过任意多个ε，得到当前的真正状态集
     * @param I 当前状态集
     * @return 当前真正的状态集(closureI)
     */
    private List<Integer> closure(List<Integer> I, String[][] f){
        // 经过任意多个ε，因此BFS
        List<Integer> closureI  = new ArrayList<>();
        Queue<Integer> queue = new LinkedList<>();
        for(int i : I){//遍历当前状态集
            queue.add(i);//进入队列
            while (!queue.isEmpty()){//队列不为空则执行循坏
                int n = queue.poll();//poll()返回队首元素的同时删除队首元素，队列为空时返回NULL
                for(int iNext = 0; iNext < f.length; iNext++){
                    for(char c : f[n][iNext].toCharArray()){
                        if(c == 'ε' && !closureI.contains(iNext)){//一个个字符对比，比如‘εb’则需要比较两次
                            closureI.add(iNext);//经过对角元素ε，得到真正的状态集
                            if(n != iNext){
                                queue.add(iNext);
                            }
                        }
                    }
                }
            }
        }
        return closureI;
    }

    /**
     * move方法：当前状态集通过某个字母可以转化到的下一状态集（一步转换，没有进行ε-闭包运算）
     * @param I 当前的状态集,letter 字母表,f 转换函数
     * @return 返回下一状态集
     */
    private List<Integer> move(List<Integer> I, char letter, String[][] f){
        List<Integer> nextI = new ArrayList<>();
        for(int i : I){
            for(int iNext = 0; iNext < f.length; iNext++){//遍历转换函数
                for(char c : f[i][iNext].toCharArray()){//读取对应于可到达状态的转换函数
                    if(c == letter && !nextI.contains(iNext)) {//一一对比
                        nextI.add(iNext);//放入下一状态集的集合中
                    }
                }
            }
        }
        return nextI;
    }


    /**
     * 判断一个Set<List>是否包含某个List
     * @param set
     * @param list
     */
    private boolean containsI(Set<List<Integer>> set, List<Integer> list){
        for(List<Integer> l : set){
            if(listEquals(l, list)){
                return true;
            }
        }
        return false;
    }

    /**
     * 判断两个List集合是否相等（不考虑顺序）
     * @param list1
     * @param list2
     */
    private boolean listEquals(List<Integer> list1, List<Integer> list2){
        list1.sort(Comparator.comparing(Integer::intValue));
        list2.sort(Comparator.comparing(Integer::intValue));
        return list1.toString().equals(list2.toString());
    }

}

输入函数类

package Utils;

import Beans.DFA;
import Beans.NFA;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/**
 * EnterUtils工具类————用于从外部获取输入，然后set给传入的nfa对象
 */
public class EnterUtils {

    /**
     * 状态集的个数（转换函数f也要用到）
     * 这个n被所有nfa类共享————为了防止出错，enterF一定要写在enterK的后面，才能保证初始化f时使用正确的n
     */
    private static int n;

    // 输入状态集
    public static void enterK(NFA nfa) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//从缓冲区中读取内容
        List<Integer> list = new ArrayList<>();//创建一个动态数组
        String[] strings = br.readLine().split("");// 一行行读取，一行放入一个字符串数组中
        for(String s : strings){
            list.add(Integer.parseInt(s));
        }//将状态集一一放入列表中
        n = list.size();//获取列表长度
        nfa.setK(list);//放入NFA状态集对应列表
    }

    // 输入字母表
    public static void enterLetters(NFA nfa) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//从缓冲区中读取内容
        char[] letters = br.readLine().toCharArray();//将字符串转换为字符数组
        nfa.setLetters(letters);//放入NFA字母表对应数组
    }

    // 输入转换函数
    public  static void enterF(NFA nfa) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//从缓冲区中读取内容
        String[][] f = new String[n][n];//n状态集长度，二维字符串数组
        for(String[] arr : f){
            Arrays.fill(arr, "");
        }//arr字符串数组初始化为空
        for(int i = 0; i < f.length; i++){
            f[i][i] = "ε";
        }//将二维字符串数组的对角元素赋值为空字符ε
        String line = "";
        while(!(line = br.readLine().trim()).equals("end")){//读取一行，直到输入"end"结束
            String[] arr = line.split("");
            f[Integer.parseInt(arr[0])][Integer.parseInt(arr[2])] += arr[1];//赋值
        }
        nfa.setF(f);//放入NFA转换函数对应二维字符串数组
    }

    // 输入初态集
    public static void enterS(NFA nfa) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//从缓冲区中读取内容
        List<Integer> list = new ArrayList<>();//创建一个动态数组
        String[] strings = br.readLine().split("");// 一行行读取，一行放入一个字符串数组中
        for(String s : strings){//遍历字符串数组
            list.add(Integer.parseInt(s));//将字符强行转换成整型后放入列表中
        }
        nfa.setS(list);//放入NFA初态集对应的整型列表中
    }

    // 输入终态集
    public static void enterZ(NFA nfa) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//从缓冲区中读取内容
        List<Integer> list = new ArrayList<>();//创建一个动态数组
        String[] strings = br.readLine().split("");// 一行行读取，一行放入一个字符串数组中
        for (String s : strings){
            list.add(Integer.parseInt(s));//将字符强行转换成整型后放入列表中
        }
        nfa.setZ(list);//放入NFA终态集对应的整型列表中
    }

}

输出函数类

package Utils;

import Beans.DFA;
import Beans.NFA;

import java.util.Arrays;

/**
 * EnterUtils工具类————用于打印nfa对象
 */
public class DisplayUtils {

    public static void displayK(NFA nfa){
        System.out.println(nfa.getK());
    }

    public static void displayLetters(NFA nfa){
        System.out.println(Arrays.toString(nfa.getLetters()));
    }

    public static void displayF(NFA nfa){
        String[][] f = nfa.getF();
        for(int i = 0; i < f.length; i++){
            for(int j = 0; j < f.length; j++){
                if(f[i][j] == "")  continue;
                for(char c : f[i][j].toCharArray()){
                    if(i == j && c == 'ε')  continue;
                    StringBuilder sb = new StringBuilder().append(i).append(c).append(j).append("  ");
                    System.out.print(sb.toString());
                }
            }
        }
        System.out.println();
    }

    public static void displayS(NFA nfa){
        System.out.println(nfa.getS());
    }

    public static void displayZ(NFA nfa){
        System.out.println(nfa.getZ());
    }


    public static void displayK(DFA dfa){
        System.out.println(dfa.getK());
    }

    public static void displayLetters(DFA dfa){
        System.out.println(Arrays.toString(dfa.getLetters()));
    }

    public static void displayF(DFA dfa){
        String[][] f = dfa.getF();
        for(int i = 0; i < f.length; i++){
            for(int j = 0; j < f.length; j++){
                if(f[i][j] == "") continue;
                for(char c : f[i][j].toCharArray()){
                    StringBuilder sb = new StringBuilder().append(i).append(c).append(j).append("  ");
                    System.out.print(sb.toString());
                }
            }
        }
        System.out.println();
    }

    public static void displayS(DFA dfa){
        System.out.println(dfa.getS());
    }

    public static void displayZ(DFA dfa){
        System.out.println(dfa.getZ());
    }

    // 一个小小的细节：
    // 打印NFA的状态转移函数时，需要将自身通过ε向自身的转化删掉
    // 而DFA压根没有ε
    //
    // 这个细节也使得，DFA是不需要ε-closure闭包运算的————move就可以唯一确定下一状态

}

测试类

package Test;

import Beans.DFA;
import Beans.NFA;
import Service.NFA2DFA;
import Utils.DisplayUtils;
import Utils.EnterUtils;

import java.io.IOException;

public class Test_NFA2DFA {
    public static void main(String[] args) throws IOException {

        NFA nfa = new NFA();

        System.out.print("请输入NFA状态集：");          EnterUtils.enterK(nfa);
        System.out.print("请输入NFA字母表：");          EnterUtils.enterLetters(nfa);
        System.out.print("请输入NFA状态转换函数：");     EnterUtils.enterF(nfa);
        System.out.print("请输入NFA初态集：");          EnterUtils.enterS(nfa);
        System.out.print("请输入NFA终态集：");          EnterUtils.enterZ(nfa);

        DFA dfa = new NFA2DFA().definite(nfa);

        System.out.print("DFA状态集：");            DisplayUtils.displayK(dfa);
        System.out.print("DFA字母表：");            DisplayUtils.displayLetters(dfa);
        System.out.print("DFA状态转换函数：");       DisplayUtils.displayF(dfa);
        System.out.print("DFA唯一初态：");          DisplayUtils.displayS(dfa);
        System.out.print("DFA终态集：");            DisplayUtils.displayZ(dfa);

    }

}

运行结果图片