多源最短路径（ Floyd算法）JAVA实现

多源最短路径（ Floyd算法）JAVA实现

package floyd;


public class Graph {	
	final int max=100;
	/*
	 * 顶点节点
	 */
	public class VexNode{
			int adjvex;
			int data;
	}
	
	VexNode[] vexNodes;
	int[] thevexs; //顶点集合
	int[][] edges = new int[max][max]; //边集合
	
	
	/*
	 * 创建图
	 */
	public void createGraph(Graph graph,int[][] A,int[] vexs) {
		thevexs=vexs;
		for (int i = 0; i < vexs.length; i++) {
			  for (int j = 0; j < vexs.length; j++) {
				  graph.edges[i][j] = A[i][j];
			}
		}
	}
	
	/*
	 * 输出图
	 */
	public void printGraph(Graph graph) {
		for (int i = 0; i < graph.thevexs.length; i++) {
			for (int j = 0; j < graph.thevexs.length; j++) {
				//没有路径则输出/
				if (graph.edges[i][j]==1000) {
					System.out.printf("%4s","/");
					 
				}else {
					System.out.printf("%4d",graph.edges[i][j]);
				}
				
			}
			System.out.println("\n");
		}
	}

}

package floyd;

public class Floyd {
	final int max = 100;
	final int INF = 1000;
	public void DispAllPath(Graph graph,int[][] A,int[][] path) {
		int i,j,k,s,d;
		int[] apath = new int[max];
		for (i=0;i<graph.thevexs.length;i++) {
				for(j=0;j<graph.thevexs.length;j++) {
						if (A[i][j] != INF && i!=j) {
							System.out.printf("顶点%d到%d最短路径长度为：%d\t路径：",i,j,A[i][j]);
							k=path[i][j];
							d=0;
							apath[d] = j;
							while (k!= -1&& k!=i) {
								d++;
								apath[d] = k;
								k = path[i][k];
							}
							d++;
							apath[d] = i;
							System.out.printf("%d", apath[d]);
							for(s=d-1;s>=0;s--) {
								System.out.printf("->%d",apath[s]);
							}
							System.out.println("\n");
						}
				}
		}
		
	}
	
	
	public void Dispdispath(int[][] A,int [][] path,int n,int k) {
		int i,j;
		System.out.printf("\tA[%d]\t\t\t\tpath[%d]\n",k,k);
		for(i=0;i<n;i++) {
				for(j=0;j<n;j++) {
					if (A[i][j]==INF) {
						System.out.printf("%4s", "*");
					} else {
						System.out.printf("%4d",A[i][j]);
					}
				}
				
				for(j=0;j<n;j++) {
					System.out.printf("%3d",path[i][j]);
				}
				System.out.println("\n");
		}
		
		
	}
	
	public Floyd(Graph graph) {
			int[][] A = new int[max][max];
			int[][] path = new int[max][max];
			int i,j,k;
			for(i=0;i<graph.thevexs.length;i++) {
					for(j=0;j<graph.thevexs.length;j++) {
						A[i][j]  = graph.edges[i][j];
						if (i!=j && graph.edges[i][j]<INF) {
							path[i][j] = i; 
						}else {
							path[i][j]=-1;
						}
					}
			}
			Dispdispath(A, path, graph.thevexs.length, -1);
			
			for(k=0;k<graph.thevexs.length;k++) {
				for(i=0;i<graph.thevexs.length;i++) {
					 for(j=0;j<graph.thevexs.length;j++) {
						 	if (A[i][j]>A[i][k]+A[k][j]) {
								A[i][j]=A[i][k]+A[k][j];
								path[i][j] = path[k][j];
							}
					 }
				}
				Dispdispath(A, path,graph.thevexs.length, k);
			}
			DispAllPath(graph, A, path);
			
	}
	
	
	
	
	
}

package floyd;



public class Test {

	public static void main(String[] args) {
		final int INF = 1000;
		int[] vexs = {0,1,2,3,4,5};
		int[][] A ={
				{0,50,10,INF,INF,INF},
				{INF,0,15,50,10,INF},
				{20,INF,0,15,INF,INF},
				{INF,20,INF,0,35,INF},
				{INF,INF,INF,30,0,INF},
				{INF,INF,INF,3,INF,0},
				
		};
		Graph graph = new Graph();
		graph.createGraph(graph, A, vexs);
		graph.printGraph(graph);
		Floyd floyd = new Floyd(graph);
	}

}

多源最短路径（ Floyd算法）JAVA实现

package floyd;


public class Graph {	
	final int max=100;
	/*
	 * 顶点节点
	 */
	public class VexNode{
			int adjvex;
			int data;
	}
	
	VexNode[] vexNodes;
	int[] thevexs; //顶点集合
	int[][] edges = new int[max][max]; //边集合
	
	
	/*
	 * 创建图
	 */
	public void createGraph(Graph graph,int[][] A,int[] vexs) {
		thevexs=vexs;
		for (int i = 0; i < vexs.length; i++) {
			  for (int j = 0; j < vexs.length; j++) {
				  graph.edges[i][j] = A[i][j];
			}
		}
	}
	
	/*
	 * 输出图
	 */
	public void printGraph(Graph graph) {
		for (int i = 0; i < graph.thevexs.length; i++) {
			for (int j = 0; j < graph.thevexs.length; j++) {
				//没有路径则输出/
				if (graph.edges[i][j]==1000) {
					System.out.printf("%4s","/");
					 
				}else {
					System.out.printf("%4d",graph.edges[i][j]);
				}
				
			}
			System.out.println("\n");
		}
	}

}

package floyd;

public class Floyd {
	final int max = 100;
	final int INF = 1000;
	public void DispAllPath(Graph graph,int[][] A,int[][] path) {
		int i,j,k,s,d;
		int[] apath = new int[max];
		for (i=0;i<graph.thevexs.length;i++) {
				for(j=0;j<graph.thevexs.length;j++) {
						if (A[i][j] != INF && i!=j) {
							System.out.printf("顶点%d到%d最短路径长度为：%d\t路径：",i,j,A[i][j]);
							k=path[i][j];
							d=0;
							apath[d] = j;
							while (k!= -1&& k!=i) {
								d++;
								apath[d] = k;
								k = path[i][k];
							}
							d++;
							apath[d] = i;
							System.out.printf("%d", apath[d]);
							for(s=d-1;s>=0;s--) {
								System.out.printf("->%d",apath[s]);
							}
							System.out.println("\n");
						}
				}
		}
		
	}
	
	
	public void Dispdispath(int[][] A,int [][] path,int n,int k) {
		int i,j;
		System.out.printf("\tA[%d]\t\t\t\tpath[%d]\n",k,k);
		for(i=0;i<n;i++) {
				for(j=0;j<n;j++) {
					if (A[i][j]==INF) {
						System.out.printf("%4s", "*");
					} else {
						System.out.printf("%4d",A[i][j]);
					}
				}
				
				for(j=0;j<n;j++) {
					System.out.printf("%3d",path[i][j]);
				}
				System.out.println("\n");
		}
		
		
	}
	
	public Floyd(Graph graph) {
			int[][] A = new int[max][max];
			int[][] path = new int[max][max];
			int i,j,k;
			for(i=0;i<graph.thevexs.length;i++) {
					for(j=0;j<graph.thevexs.length;j++) {
						A[i][j]  = graph.edges[i][j];
						if (i!=j && graph.edges[i][j]<INF) {
							path[i][j] = i; 
						}else {
							path[i][j]=-1;
						}
					}
			}
			Dispdispath(A, path, graph.thevexs.length, -1);
			
			for(k=0;k<graph.thevexs.length;k++) {
				for(i=0;i<graph.thevexs.length;i++) {
					 for(j=0;j<graph.thevexs.length;j++) {
						 	if (A[i][j]>A[i][k]+A[k][j]) {
								A[i][j]=A[i][k]+A[k][j];
								path[i][j] = path[k][j];
							}
					 }
				}
				Dispdispath(A, path,graph.thevexs.length, k);
			}
			DispAllPath(graph, A, path);
			
	}
	
	
	
	
	
}

package floyd;



public class Test {

	public static void main(String[] args) {
		final int INF = 1000;
		int[] vexs = {0,1,2,3,4,5};
		int[][] A ={
				{0,50,10,INF,INF,INF},
				{INF,0,15,50,10,INF},
				{20,INF,0,15,INF,INF},
				{INF,20,INF,0,35,INF},
				{INF,INF,INF,30,0,INF},
				{INF,INF,INF,3,INF,0},
				
		};
		Graph graph = new Graph();
		graph.createGraph(graph, A, vexs);
		graph.printGraph(graph);
		Floyd floyd = new Floyd(graph);
	}

}