计算流图中的循环集合

继续以上流图为例，上篇只求了各节点的前必经节点集合。
这篇中，计算以下几个元素：
（1）直接前必经节点
（2）求出所有的回边列表
（3）求出图中所有的循环


 1 import java.util.ArrayList;
import java.util.List;

public class Node {
    // 序号
    public int no;
    // 后接节点列表
    public List<Node> nextList = new ArrayList<Node>();
    // 前接节点列表
    public List<Node> preList = new ArrayList<Node>();
    // 前必经节点
    public List<Node> dominatorList = new ArrayList<Node>();
    //直接必经节点
    public Node zDominator=null;
    public Node(int no) {
        this.no = no;
    }

    public void addNext(Node n){
        nextList.add(n);
        n.preList.add(this);
    }
    
    public String toString(){
        return no+"";
    }
}

public class BackEdge {

    public Node fromNode;
    public Node toNode;
    
    public BackEdge(Node fromNode,Node toNode){
        this.fromNode=fromNode;
        this.toNode=toNode;
    }
}

import java.util.ArrayList;
import java.util.List;


public class Loop {

    BackEdge backEdge=null;
    List<Node> nodeList=new ArrayList<Node>();
    public Loop(BackEdge backEdge){
        this.backEdge=backEdge;
    }
    
    public void add(Node node){
        nodeList.add(node);
    }
    
    public boolean contains(Node node){
        if(nodeList.contains(node)){
            return true;
        }
        return false;
    }
    
    public String toString(){
        StringBuilder stb=new StringBuilder();
        stb.append("Loop{");
        for(int i=0;i<nodeList.size();i++){
            if(i!=0){
                stb.append(",");
            }
            stb.append(nodeList.get(i).no);
        }
        stb.append("}");
        return stb.toString();
    }
}

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Dominator {

    public static void main(String[] args) {
        // 初期化所有节点 并设置节点间连接关系
        List<Node> nodeList = getNodeList(12);
        // 计算前必经节点
        doDominator(nodeList);
        // 计算直接必经节点
        doZDominator(nodeList);
        // 打印必经节点列表
        printResult(nodeList);
        // 检索回边
        List<BackEdge> backEdgeList=searchLoop(nodeList);
        //打印回边列表
        printBackEdgeList(backEdgeList);
        //根据回边求出自然循环
        List<Loop> loopList=getLoopList(backEdgeList);
        //打印循环集合
        printLoopList(loopList);

    }

    //打印循环集合
    public static void printLoopList(List<Loop> loopList){
        System.out.println("循环列表：");
        for(int i=0;i<loopList.size();i++){
            System.out.println(i+1+":"+loopList.get(i));
        }
    }
    
    //根据回边求出自然循环
    public static List<Loop> getLoopList(List<BackEdge> backEdgeList){
        List<Loop> loopList=new ArrayList<>();
        for(BackEdge be:backEdgeList){
            LinkedList<Node> stack=new LinkedList<>();
            Loop loop=new Loop(be);
            loop.add(be.toNode);
            insertNode(be.fromNode,loop,stack);
            while(!stack.isEmpty()){
                Node m=stack.pop();
                List<Node> preList=m.preList;
                for(Node p:preList){
                    insertNode(p,loop,stack);
                }
            }
            loopList.add(loop);
        }
        return loopList;
    }
    
    
    private static void insertNode(Node node,Loop loop,LinkedList<Node> stack){
        if(loop.contains(node)){
            return;
        }
        loop.add(node);
        stack.push(node);
    }
    
    //打印回边列表
    public static void printBackEdgeList(List<BackEdge> backEdgeList){
        System.out.println("回边列表：");
        int i=1;
        for(BackEdge be:backEdgeList){
            System.out.println(i+++":"+be.fromNode.no+"->"+be.toNode.no);
        }
    }
    
    
    // 检索循环
    public static List<BackEdge> searchLoop(List<Node> nodeList) {
        List<BackEdge> backEdgeList=new ArrayList<BackEdge>();
        for (Node node : nodeList) {
            List<Node> temList = new ArrayList<Node>();
            temList.addAll(node.nextList);
            temList.retainAll(node.dominatorList);
            if (!temList.isEmpty()) {
                for (Node toNode : temList) {
                    BackEdge be = new BackEdge(node, toNode);
                    backEdgeList.add(be);
                }
            }
        }
        return backEdgeList;
    }

    // 计算直接必经节点
    public static void doZDominator(List<Node> nodeList) {
        for (Node node : nodeList) {
            List<Node> dominatorList = node.dominatorList;
            if (dominatorList.size() == 1) {
                continue;
            }
            int maxSize = 1;
            for (Node dNode : dominatorList) {
                if (dNode == node) {
                    continue;
                }
                int size = dNode.dominatorList.size();
                if (size >= maxSize) {
                    maxSize = size;
                    node.zDominator = dNode;
                }
            }

        }
    }

    // 打印必经结果
    public static void printResult(List<Node> nodeList) {
        for (int i = 0; i < nodeList.size(); i++) {
            Node node = nodeList.get(i);
            System.out.println("*******************");
            System.out.println("node" + (i + 1));
            System.out.print("前必经节点:");
            printNodeListNo(node.dominatorList);
            System.out.println("直接必经节点:" + node.zDominator);
            System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!");
        }
    }

    // 打印节点NO
    public static void printNodeListNo(List<Node> nodeList) {
        for (int i = 0; i < nodeList.size(); i++) {
            if (i != 0) {
                System.out.print(",");
            }
            System.out.print(nodeList.get(i).no);
        }
        System.out.println();
    }

    // 计算必经节点
    public static void doDominator(List<Node> nodeList) {
        // 迭代次数
        int n = 1;
        // 判断状态是否稳定Flag
        boolean changed = true;
        while (changed) {
            System.out.println("迭代次数:" + n++);
            changed = false;
            for (int i = 0; i < nodeList.size(); i++) {
                Node node = nodeList.get(i);
                List<Node> lastDominatorList = new ArrayList<Node>();
                lastDominatorList.addAll(node.dominatorList);
                List<Node> temList = new ArrayList<Node>();

                for (Node preNode : node.preList) {
                    List<Node> preDomList = preNode.dominatorList;
                    if (temList.isEmpty()) {
                        temList.addAll(preDomList);
                    } else {
                        temList.retainAll(preDomList);
                    }
                }
                temList.add(node);
                int lastSize = lastDominatorList.size();
                lastDominatorList.retainAll(temList);
                if (lastSize != lastDominatorList.size()) {
                    node.dominatorList = temList;
                    changed = true;
                }
            }
        }
    }

    // 初期化所有节点 并设置节点间连接关系
    public static List<Node> getNodeList(int size) {
        List<Node> nodeList = new ArrayList<Node>(size);
        for (int i = 0; i < size; i++) {
            Node node = new Node(i + 1);
            nodeList.add(node);
        }
        Node node1 = nodeList.get(0);
        Node node2 = nodeList.get(1);
        Node node3 = nodeList.get(2);
        Node node4 = nodeList.get(3);
        Node node5 = nodeList.get(4);
        Node node6 = nodeList.get(5);
        Node node7 = nodeList.get(6);
        Node node8 = nodeList.get(7);
        Node node9 = nodeList.get(8);
        Node node10 = nodeList.get(9);
        Node node11 = nodeList.get(10);
        Node node12 = nodeList.get(11);
        // 节点之间关系设定
        node1.addNext(node2);
        //
        node2.addNext(node3);
        node2.addNext(node4);
        //
        node3.addNext(node2);
        //
        node4.addNext(node2);
        node4.addNext(node5);
        node4.addNext(node6);
        //
        node5.addNext(node7);
        node5.addNext(node8);
        //
        node6.addNext(node7);
        //
        node7.addNext(node11);
        //
        node8.addNext(node9);
        //
        node9.addNext(node8);
        node9.addNext(node10);
        //
        node10.addNext(node5);
        node10.addNext(node12);
        //
        node11.addNext(node12);
        // 初期化前必经节点的列表
        for (int i = 0; i < nodeList.size(); i++) {
            nodeList.get(i).dominatorList.addAll(nodeList);
        }
        return nodeList;
    }

}