無向グラフトラバーサルアルゴリズム
最近、無向グラフをトラバースする必要があるアルゴリズムに遭遇しました。グラフの特定のノードからトラバースして、特定のタイプのノードの終わりまでのすべてのパスを見つける必要があります。多くのアルゴリズムがオンラインで見つかりましたが、どれも信頼性が高くありません。後で私はこれがより信頼できることを発見しました。次のように構成されています。
アルゴリズムの目標：
在一个无向连通图中求出两个给定点之间的所有路径；
アルゴリズムのアイデア：
-
ノード間の関係を整理し、ノードごとにセットを作成します。このセットには、ノードに直接接続されているすべてのノード（ノード自体を除く）が格納されます。
-
2つのポイントを定義します。一方は開始ノードで、もう一方は終了ポイントです。2つの間のすべてのパスを解決する問題は、次のサブ問題に分解できます。開始ノードに直接接続されているノードごとに、次のように解決します。エンドポイントのすべてのパス（パスには開始ノードが含まれていません）はパスセットを取得しますこれらのパスセットを追加して、開始ノードから終了ポイントまでのすべてのパスを取得しますなど、再帰のアイデアは、エンドポイントまで再帰的に適用できます、必要なパスが見つかった場合は、ダンプして印刷します。ループが見つかった場合、または行き止まりが見つかった場合は、パスの検索を停止して戻ります。
-
スタックを使用して、現在見つかっているパス（完全なパスではない）上のノードを保存し、完全なパスが見つかるたびにスタックの一番上のノードをポップします。また、スタックの一番上のノードから下に進むことができないパスに遭遇したときにスタックをポップしますバックトラッキングを実現するための最上位ノード。
コードとテストは次のとおりです。
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