求图中某点到另一点的通路

    图的搜索方法有DFS和BFS，但是这两个算法不能直接得到（其实是我不会）图中任意一点到另外一点的通路路径，以图中某个点作为起点，另外一点作为终点，从终点开始，利用邻接表，从后向前查找，首先查找可以直接到终点的节点，放入集合S1中，然后再查找可以直接到S1的节点，存入集合S2，只到找到起点为止。代码如下：

public static  void getReachableNodeCollection(){
        ArrayList<ArrayList<Integer>> reachableNodeCollection=new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> reachableNode=new ArrayList<>();
        ArrayList<Integer> tempNeighbour;
        final ArrayList<Integer> keySet=new ArrayList<>();
        for (Integer key:neighbourTable.keySet()){
            if (!key.equals(demandRouterArray[1]))
            {
                keySet.add(key);
            }
        }
        Integer key;
        tempNeighbour=new ArrayList<>();
        for (int i = 0; i < keySet.size(); i++) {
            key=keySet.get(i);
            tempNeighbour.addAll(neighbourTable.get(key));
            if ((tempNeighbour.contains(demandRouterArray[1]))){
                reachableNode.add(key);
                //continue;

            }
            tempNeighbour.clear();

        }
        reachableNodeCollection.add(new ArrayList<Integer>(reachableNode));//到最后一个节点的节点集合存在第一个位置，将来获得路径是要逆序访问
        ArrayList<Integer> copyOfReachableNode;
        ArrayList<Integer> currentKeySet=new ArrayList<>(keySet);
        currentKeySet.removeAll(reachableNode);
        Integer NodeId;
        copyOfReachableNode=new ArrayList<>();
        boolean findStartNode=false;
        Integer startNodeId=demandRouterArray[0];
        while(currentKeySet.size()>0&&!reachableNode.contains(startNodeId)){
            copyOfReachableNode.addAll(reachableNode);
            reachableNode.clear();
            for (int i = 0; i <currentKeySet.size() ; i++) {
                key=currentKeySet.get(i);

                tempNeighbour.addAll(neighbourTable.get(key));
                for (int j = 0; j <copyOfReachableNode.size() ; j++) {
                    NodeId=copyOfReachableNode.get(j);
                    if (tempNeighbour.contains(NodeId)){
                        reachableNode.add(key);
                        if (key.equals(startNodeId)){
                            findStartNode=true;//如果已经找到起始点，就跳出搜索
                        }
                        break;
                    }
                }
                tempNeighbour.clear();
                if (findStartNode){
                    break;
                }
            }
            reachableNodeCollection.add(new ArrayList<Integer>(reachableNode));
            currentKeySet.removeAll(reachableNode);
            copyOfReachableNode.clear();
            if (findStartNode){
                break;
            }
        }
        System.out.println();
    }

其中，从后向前查找时，首先查找到的节点ID存储在reachableNodeCollection中，如下：

 reachableNodeCollection.add(new ArrayList<Integer>(reachableNode));

    由于之后要将reachableNode使用clear()方法清空，所以这里需要使用new创建一个新的ArrayList对象，在新的空间中拷贝了一份reachableNode中的引用，这些引用指向一些Integer对象。如果不是有new创建新对象，而是直接使用如下形式的话

reachableNodeCollection.add(reachableNode));

这里只是将reachableNode的地址添加进来，当reachableNode.clear()之后，reachableNode中的引用被清空，reachNodeCollection自然也找不到原先的Integer内容了。