java 迭代算法使用—找节点路径

如上图找出从H到A的节点：

public class Test4 {

    private Stack<String> stack=new Stack<>();
    private  List<List<String>> sers =new ArrayList<>();

    public Test4() {

        List<Map<String, List<String>>> alls=getAll();
        iterationTest("H",null, "H", "A", alls);

        for(int i=0;i<sers.size();i++){
            System.out.println(sers.get(i));
        }
    }

    private boolean isNotInStack(String RoadWay){

        Iterator<String> it = stack.iterator();
        while (it.hasNext()) {
            String node = (String) it.next();
            if (RoadWay == node)
                return true;
        }
        return false;
    }

    private boolean iterationTest(String curr, String pre, String start, String end,List<Map<String, List<String>>>  alls) {

        String next = null;
        /* 如果符合条件判断说明出现环路，不能再顺着该路径继续寻路*/
        if (curr != null && pre != null && curr.equals(pre))
            return false;
        //当前栈中的长度超出集合中的
        if(sers.size()>0){
            if(stack.size()>=sers.get(0).size()){
                return false;
            }
        }
        stack.push(curr);
        if (end.equals(curr)){
            showAndSavePath();
            return true;
        }
        //当前不是最后一个
        List<String> connects = getConnects(curr,alls);
        for(int i=0;i<connects.size();i++){
            next = connects.get(i);
            if (pre != null&&(
                    next == start||
                    next == pre||
                    isNotInStack(next))) {
                continue;
            }
            if (iterationTest(next, curr, start, end,alls)){/* 递归调用 */
                stack.pop();
            }
        }
        //说明该节点除了与上一个节点相连外，没有节点与他相连，直接出栈
        stack.pop();
        return false;
    }

    private void showAndSavePath(){

        List<String> o =  new ArrayList<String>(stack);
        for(int i =0;i<sers.size();i++){
            if(sers.get(i).size()>=o.size()){
                sers.remove(i);
                i--;
            }
        }
        sers.add(o); /* 转储 */
    }

    private List<Map<String, List<String>>> getAll() {

        List<Map<String, List<String>>> alls=new ArrayList<>();

        Map<String, List<String>> mapA=new HashMap<>();
        List<String> listA = new ArrayList<String>();
        listA.add("B");
        mapA.put("A",listA);

        Map<String, List<String>> mapB=new HashMap<>();
        List<String> listB = new ArrayList<String>();
        listB.add("A");
        listB.add("C");
        mapB.put("B",listB);

        Map<String, List<String>> mapC=new HashMap<>();
        List<String> listC = new ArrayList<String>();
        listC.add("B");
        listC.add("D");
        mapC.put("C",listC);

        Map<String, List<String>> mapD=new HashMap<>();
        List<String> listD = new ArrayList<String>();
        listD.add("C");
        listD.add("E");
        listD.add("L");
        mapD.put("D",listD);

        Map<String, List<String>> mapE=new HashMap<>();
        List<String> listE = new ArrayList<String>();
        listE.add("D");
        listE.add("F");
        listE.add("G");
        mapE.put("E",listE);

        Map<String, List<String>> mapF=new HashMap<>();
        List<String> listF = new ArrayList<String>();
        listF.add("E");
        mapF.put("F",listF);

        Map<String, List<String>> mapG=new HashMap<>();
        List<String> listG = new ArrayList<String>();
        listG.add("E");
        listG.add("H");
        listG.add("L");
        mapG.put("G",listG);

        Map<String, List<String>> mapH=new HashMap<>();
        List<String> listH = new ArrayList<String>();
        listH.add("G");
        listH.add("I");
        listH.add("K");
        mapH.put("H",listH);

        Map<String, List<String>> mapI=new HashMap<>();
        List<String> listI = new ArrayList<String>();
        listI.add("H");
        listI.add("J");
        mapI.put("I",listI);

        Map<String, List<String>> mapJ=new HashMap<>();
        List<String> listJ = new ArrayList<String>();
        listJ.add("I");
        listJ.add("M");
        listJ.add("K");
        mapJ.put("J",listJ);

        Map<String, List<String>> mapK=new HashMap<>();
        List<String> listK = new ArrayList<String>();
        listK.add("H");
        listK.add("J");
        listK.add("L");
        mapK.put("K",listK);

        Map<String, List<String>> mapL=new HashMap<>();
        List<String> listL = new ArrayList<String>();
        listL.add("K");
        listL.add("G");
        listL.add("D");
        mapL.put("L",listL);

        Map<String, List<String>> mapM=new HashMap<>();
        List<String> listM = new ArrayList<String>();
        listM.add("J");
        mapM.put("M",listM);

        alls.add(mapA);
        alls.add(mapB);
        alls.add(mapC);
        alls.add(mapD);
        alls.add(mapE);
        alls.add(mapG);
        alls.add(mapH);
        alls.add(mapI);
        alls.add(mapJ);
        alls.add(mapK);
        alls.add(mapL);
        alls.add(mapM);
        return alls;
    }

    private List<String> getConnects(String key, List<Map<String, List<String>>> alls){

        List<String> connects=new ArrayList<>();
        for(Map<String, List<String>> param:alls){
            if(param.get(key)!=null){
                connects=param.get(key);
                break;
            }
        }
        return connects;
    }

    public static void main(String[] args) {

        new Test4();
    }
}