Floyd 算法 和 非递归算法寻路

Floyd 算法是用于多源的最短路径的算法，给予动态规划的思想实现。

Floyd 算法的最短路径的寻找需要借助递归函数，但是一些时候，递归函数无法使用。因此，我将其改为了非递归函数。非递归函数使用栈作为数据存储器，查询路径（即最短路径的所有中间节点，按序输出）。

代码如下：

注：以下代码，其中flod函数实现了Floyd算法，使用Java和spark混合实现。 另外两个函数分别是输出最短路径的，一个是递归方法，一个是非递归方法，这两个都是完全Java实现。

	public static  Tuple2   flod(int[][] dis){
		int lg = dis.length;
//		System.out.println("res:");
		int[][] res = new int[lg][lg];
		int[][] path= new int[lg][lg];
		for (int i=0;ires[i][k]+res[k][j]){
						res[i][j] = res[i][k]+res[k][j];
						path[i][j] =  k;
					}					
				}
			}
		}
		Tuple2 tp_res = new Tuple2(res, path);
		return tp_res;
	}
	
	public static void  getpath(int[][] path, int beg, int end,  ArrayList ways){ 
		///////////   middle nodes in the path, not including start and end nodes    //////
//		System.out.println(beg+" "+end+" : "+path[beg][end]);
		if (path[beg][end]==-1 ){
			return;
		}
		
		getpath(path, beg, path[beg][end], ways);
		ways.add(Integer.valueOf(path[beg][end]));		
		getpath(path, path[beg][end], end, ways);
	}
	
	
	public static ArrayList getpath_nonrecursive(int[][] path, int beg, int end){
		ArrayList pnodes = new ArrayList<>();
		if (path[beg][end]==-1){			
			return pnodes;
		}				
		java.util.Stack st = new java.util.Stack();	
		st.push(end);
//		st.push(path[beg][end]);
		
		int val= path[beg][end],kk=beg;
		
		while(st.isEmpty()==false){
//			System.out.println("beg: "+beg + " val:"+val);
			while (path[beg][val]!=-1){
				st.push(path[beg][val]);
				val = path[beg][val];				
			}	
//			val = beg;				
			if (!pnodes.contains(Integer.valueOf(val))){
				pnodes.add(Integer.valueOf(val));
			}		
			if (st.isEmpty()==false){
				kk = (int) st.pop();
		
			}else{
				continue;
			}
//			System.out.println("val:\t"+val+"\t kk: "+kk);
			if  (path[val][kk]!=-1){		
				st.push(kk);
				st.push(path[val][kk]);
				st.push(val);
				beg = val;
				val = path[val][kk];
//				val = (int) st.pop();					
			}
		

		}
		
		return pnodes;
	}