DAG路径输出（递归、深度优先搜索）

1、先定义图的节点，节点ID和下一节点号

package dyfu.algorithm;

import java.util.LinkedList;

//图的节点
public class Node {
	
	private Integer id;	//节点
	
	private LinkedList<Node> nextNode = null;	//下一节点
	
	private boolean isVisted = false;
	
	public Node(Integer id) {
		this.id = id ;
	}
	
	public void setId(int id) {
		this.id = id ;
	}
	
	public Integer getId() {
		return id;
	}
	
	public void addNextNode(Node n) {
		
		if(nextNode == null) {
			nextNode = new LinkedList<Node>();
			nextNode.add(n);
		}else {
			nextNode.add(n);
		}	
	}
	
	public LinkedList<Node> getNextNode() {
		
			return nextNode;
		
	}
	
	public void setIsVisted(boolean b) {
		this.isVisted = b;
	}
	
	public boolean getIsVisted() {
		return this.isVisted;
	}
	
}

2、计算路径

package dyfu.algorithm;

import java.util.Set;
import java.util.Stack;

public class NodeDAGList {
	
	private Stack<Node> stack = new Stack<Node>();
	
	public void findPathByNode(Node n) {
		
		stack.push(n);
		
		if(n.getNextNode() != null) {
			
			for(Node node:n.getNextNode()) {
					findPathByNode(node);			
			}
			stack.pop();	
		}else {
			printPath(stack);
			if(!stack.isEmpty()) {
				stack.pop();
			}
			return;
		}
		
	}
	
	//打印节点之间的路径
	public void printPath( Stack<Node> s) {
		
		String path = "【";
		for(Node sNode:s) {
			path = path  + sNode.getId()+ "->";
		}
		
		System.out.println(path.substring(0, path.length()-2)+"】");
	}
	
	public void setVisitedFalse(Set<Node> set) {
		
		for(Node setnode:set) {
			setnode.setIsVisted(false);
		}
	}

}

3、构造图并计算输出路径

package dyfu.algorithm;

import java.util.HashSet;
import java.util.Set;

public class NodeDAGItem {
	
	public static void main(String[] args) {
		
		//构造图
		Set<Node> setNodes = new HashSet<Node>();
		Node node1 = new Node(1);
		setNodes.add(node1);
		Node node2 = new Node(2);
		setNodes.add(node2);
		Node node3 = new Node(3);
		setNodes.add(node3);
		Node node4 = new Node(4);
		setNodes.add(node4);
		Node node5 = new Node(5);
		setNodes.add(node5);
		
		node1.addNextNode(node2);
		node1.addNextNode(node3);
		
		node2.addNextNode(node5);
		
		node3.addNextNode(node4);
		
		node4.addNextNode(node2);
		node4.addNextNode(node5);
		
		for(Node node : setNodes) {
			System.out.println("The Node ["+node.getId()+"] =");
			NodeDAGList pathlist = new NodeDAGList();
			pathlist.findPathByNode(node);
			pathlist.setVisitedFalse(setNodes);
		}
	}

}

输出结果（如果图很大的话，时间复杂度挺大，递归不是一个很好的选择）：