Cracking the coding interview--Q4.2

原文：

Given a directed graph, design an algorithm to find out whether there is a route between two nodes.

译文：

给定一个有向图，设计算法判断两结点间是否存在路径。

根据题意，给定一个有向图和起点终点，判断从起点开始，是否存在一条路径可以到达终点。 考查的就是图的遍历，从起点开始遍历该图，如果能访问到终点， 则说明起点与终点间存在路径。稍微修改一下遍历算法即可。

package chapter_4_TreesandGraphs;

import java.util.Scanner;


/**
 * 边集
 */
class ArcNode{
	public int data;
	public ArcNode next;
	
	public ArcNode(int data) {
		this.data = data;
		this.next = null;
	}
	
	public void printArcNode() {
		System.out.format(" %d -->", data);
	}
}

/**
 * 顶点集
 */
class VexNode {
	public int data;
	public ArcNode first;
	
	public VexNode(int data) {
		this.first = null;
		this.data = data;
	}
	
	public void addArc(int arcdata) {
		ArcNode p = null;
		ArcNode arcNode = new ArcNode(arcdata);
		if(first == null) {
			first = arcNode;
		} else {
			p = first;
			first = arcNode;
			arcNode.next = p;
		}
	}
	
	public void printVexNode() {
		System.out.format("顶点  %d :", data);
		ArcNode arcNode = first;
		while(arcNode != null) {
			if(arcNode.next != null) {
				arcNode.printArcNode();
			} else {
				System.out.format(" %d ", arcNode.data);
			}
			arcNode = arcNode.next;
		}
		System.out.format("\n");
	}
}

/**
 * 有向图
 */
class Graph {
	public int vexNum; // 顶点数目
	public int arcNum; // 边数目
	public VexNode[] adj;
	
	public boolean visited[];
	
	public Graph(int vexNum) {
		this.vexNum = vexNum;
		this.arcNum = 0;
		adj = new VexNode[vexNum];
	}
	
	public void addNode(int node) {
		for(int i=0; i<vexNum; i++) {
			if(adj[i] == null) {
				adj[i] = new VexNode(node);
				return;
			}
		}
	}
	
	public void addArc(int start, int end) {
		for(int i=0; i<vexNum; i++) {
			if(adj[i].data == start) {
				adj[i].addArc(end);
				return;
			}
		}
		System.out.format("顶点  %d 不存在该结点信息！\n", start);
	}
	
	public void printGraph() {
		for(int i=0; i<vexNum; i++) {
			if(adj[i] == null) {
				return;
			}
			adj[i].printVexNode();
		}
	}
	
	public void DFSTraverse() {
		visited = new boolean[vexNum];
		for(boolean tem:visited) {
			tem = false;
		}
		
		for(int i=0; i<vexNum; i++) {
			if(visited[i] == false) {
				DFS(i);
			}
		}
	}
	
	public void DFS(int i) {
		visit(i);
		visited[i] = true;
		ArcNode arcNode = adj[i].first;
		while(arcNode != null) {
			int index = findIndex(arcNode.data);
			if(visited[index] == false) {
				DFS(index);
			}
			arcNode = arcNode.next;
		}
		
	}
	
	/**
	 * 默认从第一个结点出发的广度遍历算法
	 */
	public void BFSTraverse() {
		boolean visited[] = new boolean[vexNum];
		for(boolean tem: visited) {
			tem = false;
		}
		
		for(int i=0; i<vexNum; i++) {
			if(visited[i] == false) {
				visit(i);
				visited[i] = true;
				
				int queue[] = new int[vexNum];
				int head = 0;
				int tail = 0;
				
				queue[tail++] = adj[i].data;
				
				while(head < tail) {
					int cur = queue[head++];
					ArcNode arcNode = adj[i].first;
					while(arcNode != null) {
						int index = findIndex(arcNode.data);
						if(visited[index] == false) {
							visit(index);
							visited[index] = true;
							queue[tail++] = index;
						}
						arcNode = arcNode.next;
					}
				}
			}
		}
	}
	
	public void visit(int i) {
		System.out.print(" " + adj[i].data);
	}
	
	public int findIndex(int value) {
		int index = -1;
		for(int i=0; i<vexNum; i++) {
			if(adj[i].data == value) {
				index = i;
				break;
			}
		}
		return index;
	}
	
	public boolean route(int m, int n) {
		boolean visited[] = new boolean[vexNum];
		for(boolean tem: visited) {
			tem = false;
		}
		int index = findIndex(m);
		int[] queue = new int[vexNum];
		int head = 0;
		int tail = 0;
		queue[tail++] = index;
		while(head < tail) {
			int cur = queue[head++];
			visited[cur] = true;
			if(adj[cur].data == n) {
				return true;
			}
			ArcNode arcNode = adj[cur].first;
			while(arcNode != null) {
				index = findIndex(arcNode.data);
				if(visited[index] == false) {
					if(arcNode.data == n) {
						return true;
					}
					queue[tail++] = index;
				}
				arcNode = arcNode.next;
			}
		}
		return false;
	}
}

/**
 * 
 * 给定一个有向图，设计算法判断两结点间是否存在路径。
 * 
 */
public class Question_4_2 {
	public static void main(String args[]) {
		Scanner scanner = new Scanner(System.in);
		int arcnum = scanner.nextInt();
		scanner.nextLine();
		Graph graph = new Graph(arcnum);
		String nodeString = scanner.nextLine();
		String nodes[] = nodeString.split(" ");
		for(int i=0; i<nodes.length; i++) {
			graph.addNode(Integer.parseInt(nodes[i]));
		}
		while(true) {
			int start = scanner.nextInt();
			int end = scanner.nextInt();
			scanner.nextLine();
			if(start == 0 && end ==0) {
				break;
			}
			graph.addArc(start, end);
		}
		
		graph.printGraph();
		
		System.out.println("广度遍历 ：");
		graph.BFSTraverse();
		
		System.out.println("\n深度遍历 ：");
		graph.DFSTraverse();
		
		System.out.println("\n输入需要检验的两个结点 ：");
		int m = scanner.nextInt();
		int n = scanner.nextInt();
		
		boolean result = graph.route(m, n);
		if(result) {
			System.out.format("%d   %d 存在路径", m,n );
		} else {
			System.out.format("%d   %d 不存在路径", m,n );
		}
	}
}