无向图入口、出口遍历算法

无向图遍历算法

最近遇到一个需要遍历无向图的算法，需要从图的某一个结点开始遍历，找出到某一类结点结束的所有路径。网上找了很多算法，都不是很靠谱。后来发现这个比较靠谱。整理如下：

算法目标：

在一个无向连通图中求出两个给定点之间的所有路径；

算法思路：

1. 整理节点间的关系，为每个节点建立一个集合，该集合中保存所有与该节点直接相连的节点（不包括该节点自身）；

2. 定义两点一个为起始节点，另一个为终点，求解两者之间的所有路径的问题可以被分解为如下所述的子问题：对每一 个与起始节点直接相连的节点，求解它到终点的所有路径（路径上不包括起始节点）得到一个路径集合，将这些路径集合相加就可以得到起始节点到终点的所有路径；依次类推就可以应用递归的思想，层层递归直到终点，若发现希望得到的一条路径，则转储并打印输出；若发现环路，或发现死路，则停止寻路并返回；

3. 用栈保存当前已经寻到的路径（不是完整路径）上的节点，在每一次寻到完整路径时弹出栈顶节点；而在遇到从栈顶节点无法继续向下寻路时也弹出该栈顶节点，从而实现回溯。

代码及测试如下：

import java.util.*;

public class test {
    /* 临时保存路径节点的栈 */
    public static Stack<Node> stack = new Stack<Node>();
    /* 存储路径的集合 */
    public static ArrayList<Node[]> sers = new ArrayList<>();

    /* 判断节点是否在栈中 */
    public static boolean isNodeInStack(Node node) {
        Iterator<Node> it = stack.iterator();
        while (it.hasNext()) {
            Node node1 = it.next();
            if (node == node1)
                return true;
        }
        return false;
    }

    /* 此时栈中的节点组成一条所求路径，转储并打印输出 */
    public static void showAndSavePath() {
        Node[] o = stack.stream().toArray(Node[]::new);
        for (int i = 0; i < o.length; i++) {
            Node nNode = o[i];

            if (i < (o.length - 1))
                System.out.print(nNode.getName() + "->");
            else
                System.out.print(nNode.getName());
        }
        sers.add(o); /* 转储 */
        System.out.println("\n");
    }

    /*
     * 寻找路径的方法
     * cNode: 当前的起始节点currentNode
     * pNode: 当前起始节点的上一节点previousNode
     * sNode: 最初的起始节点startNode
     * eNode: 终点endNode
     */
    public static boolean getPaths(Node cNode, Node pNode, Node sNode) {
        Node nNode = null;
        /* 如果符合条件判断说明出现环路，不能再顺着该路径继续寻路，返回false */
        if (cNode != null && pNode != null && cNode == pNode)
            return false;

        if (cNode != null) {
            int i = 0;
            /* 起始节点入栈 */
            stack.push(cNode);
            /* 如果该起始节点就是终点，说明找到一条路径 */
            //这里可以增加多个规则，比如不经过某些结点，某类结点标识出口，如果存在重复结点及路径的时候
            //可以通过记录已有路径的首位结点来过滤重复路径等。
            if (cNode.name.equalsIgnoreCase("node2")) return true;
            if (cNode.name.equalsIgnoreCase("node8")) {
                /* 转储并打印输出该路径，返回true */
                showAndSavePath();
                return true;
            }
            /* 如果不是,继续寻路 */
            else {
                /*
                 * 从与当前起始节点cNode有连接关系的节点集中按顺序遍历得到一个节点
                 * 作为下一次递归寻路时的起始节点
                 */
                nNode = cNode.getRelationNodes().get(i);
                while (nNode != null) {
                    /*
                     * 如果nNode是最初的起始节点或者nNode就是cNode的上一节点或者nNode已经在栈中 ，
                     * 说明产生环路 ，应重新在与当前起始节点有连接关系的节点集中寻找nNode
                     */
                    if (pNode != null && (nNode == sNode || nNode == pNode || isNodeInStack(nNode))) {
                        i++;
                        if (i >= cNode.getRelationNodes().size())
                            nNode = null;
                        else {
                            nNode = cNode.getRelationNodes().get(i);
                        }
                        continue;
                    }

                    /* 以nNode为新的起始节点，当前起始节点cNode为上一节点，递归调用寻路方法 */
                    if (getPaths(nNode, cNode, sNode))/* 递归调用 */ {
                        /* 如果找到一条路径，则弹出栈顶节点 */
                        stack.pop();
                    }
                    /* 继续在与cNode有连接关系的节点集中测试nNode */
                    i++;
                    if (i >= cNode.getRelationNodes().size())
                        nNode = null;
                    else
                        nNode = cNode.getRelationNodes().get(i);
                }
                /*
                 * 当遍历完所有与cNode有连接关系的节点后，
                 * 说明在以cNode为起始节点到终点的路径已经全部找到
                 */
                stack.pop();
                return false;
            }
        } else
            return false;
    }

    public static void main(String[] args) {
        /* 定义节点数组 */
        Node[] node = new Node[11];

        for (int i = 0; i < node.length; i++) {
            node[i] = new Node();
            node[i].setName("node" + (i + 1));
            node[i].id = i;
        }

        node[0].setRelationNodes(Arrays.asList(node[3], node[1], node[10]));
        node[1].setRelationNodes(Arrays.asList(node[0], node[2], node[3]));
        node[2].setRelationNodes(Arrays.asList(node[1], node[4], node[10]));
        node[3].setRelationNodes(Arrays.asList(node[0], node[1], node[5], node[8], node[10]));
        node[4].setRelationNodes(Arrays.asList(node[2], node[8], node[9]));
        node[5].setRelationNodes(Arrays.asList(node[3], node[6]));
        node[6].setRelationNodes(Arrays.asList(node[5], node[7], node[8]));
        node[7].setRelationNodes(Arrays.asList(node[6], node[8]));
        node[8].setRelationNodes(Arrays.asList(node[1], node[3], node[6], node[7], node[4], node[10]));
        node[9].setRelationNodes(Arrays.asList(node[4], node[10]));
        node[10].setRelationNodes(Arrays.asList(node[9]));

        /* 开始搜索所有路径 */
        getPaths(node[0], null, node[0]);
    }

    public static class Node {
        private Integer id;
        public String name = null;
        public List<Node> relationNodes = new ArrayList<Node>();

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public List<Node> getRelationNodes() {
            return relationNodes;
        }

        public void setRelationNodes(List<Node> relationNodes) {
            this.relationNodes = relationNodes;
        }
    }

}

以上算法参考无向图如下：

[图片]

计算的是从1开始，寻找出口为8的路径，路径中不包含2结点。

结果如下

node1->node4->node6->node7->node8

node1->node4->node6->node7->node9->node8

node1->node4->node9->node7->node8

node1->node4->node9->node8

node1->node4->node11->node10->node5->node9->node7->node8

node1->node4->node11->node10->node5->node9->node8

node1->node11->node10->node5->node9->node4->node6->node7->node8

node1->node11->node10->node5->node9->node7->node8

node1->node11->node10->node5->node9->node8