距离向量算法java代码

A. java中向量计算用array

for(int i = 0; i<v1.length; i++);
如果上面这行就是你原来的代码的话，那问题就很可能是多了个";"号
这个";"将这个for循环结束了，i就无效了，接下了i就是没有定义的了；
应该将这个“；”去掉就行了。

B. 如何用JAVA实现距离向量算法急求！！！！！！

一个实例代表一个路由器(结点)。 npk )= S
实例之间利用UDP交换路由表。 wtw%
)db
能够打印出邻居列表和输出路由表！

C. 求java代码，关于带权有向图找最短距离，数据结构方面

so..................复杂

D. 一个java面试题：用类求平面上两点间距离，求知道

//首先你得明确平面上的点是一个坐标。我就构造这样一个点
public class Point {
private int x;
private int y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}

//有了点我们去哪么根据勾股定理
// 求出x轴和y轴两点之间的距离
然后就是求这两点距离的算法。很好的Math给我们提供了算法
所以：

public class TestMath {
public static void main(String[] args) {
Point p1=new Point(1,2);
Point p2=new Point(-5,-4);
// 哪么勾股定理你应该知道把
// 求出x轴和y轴两点之间的距离
int x=p1.getX()-p2.getX();
int y=p1.getY()-p2.getY();
double l=Math.hypot(x, y);
System.out.println(l);
}
}

面试题只是问你这样一个思路。你还可以更详细的告诉他。开根的过程先求x的二次方y的二次方然后求和开根，

E. 写出RIP路由协议使用距离向量路由算法。（2求路由器A更新后的路由表，根据算法详述路由表项的更新过程。

1 距离向量路由算法(Bellman-Ford Routing Algorithm)，也叫做最大流量算法(Ford-Fulkerson Algorithm)，其被距离向量协议作为一个算法，如RIP, BGP, ISO IDRP, NOVELL IPX。使用这个算法的路由器必须掌握这个距离表(它是一个一维排列-“一个向量”)，它告诉在网络中每个节点的最远和最近距离。
2 DEST COST NEXTHOP
A 0 -
B 3 B
C 4 B
D 5 B

F. JAVA实现距离矢量算法

public static void main(String[] args) {
new Jsq();
}

/* 利用构造进行实例化 */
public Jsq() {

G. java两点间距离公式

哈哈，小伙愁了把，两点距离这个就要用到数学的直角三角形的一个算法了，
直角三角形的公式：直角边A的平方 + 直角边B的平方 ＝ 斜边C的平方
可以算出：
10 - 0 = 10 (直角边A)
a点的x坐标 - b点的x坐标 = a点到b点的横向直线距离 (直角边A)

30.5 - 0 = (直角边B)
a点的y坐标 - b点的y坐标 = a点到b点的竖向直线距离 (直角边B)

那么 (10*10 + 30.5*30.5)开平方 就是斜边距离了
java的API有开平方方法 java.lang.Math.sqrt() 这个就是开平方

编程写法：
double x1=0, y1=0, x2=10, y2=30.5;
double temp_A, temp_B;
double C; // 用来储存算出来的斜边距离
temp_A = x1>x2 ? (x1-x2) : (x2-x1); // 横向距离 (取正数，因为边长不能是负数)
temp_B = y1>y2 ? (y1-y2) : (y2-y1); // 竖向距离 (取正数，因为边长不能是负数)
C=java.lang.Math.sqrt(temp_A*temp_A + temp_B*temp_B); // 计算

最后算出来的C的值 就是斜边距离

H. 距离向量的算法

距离向量算法的思想很简单：所有参加RIP协议的路由器周期性地向外广播路由刷新报文，主要内容是由很多路由项（entry）组成的路由刷新报文。对路由来说，最主要的内容是目的地址和下一跳地址（next hop）。对动态路由协议来说，为了找到本协议概念中的最佳路由，还必须注重路由的开销（metric）。所以路由项主要包括了目的地址、下一跳地址和路由开销。其他的如路由标记（tag）等内容在讲报文格式时，将具体讲到。在设计时，每个路由器的另外RIP治理了一个路由数据库，该路由数据库为系统中所有可能的信宿包含一个路由项，并为每个信宿保留如下信息：
·目的地址：在算法的IP实现中，这指的是主机或网络的IP 地址。
·下一跳地址：到信宿的路由中的第一个路由器。
·接口：用于到下一跳物理网络。
·metric值：一个数，指明本路由器到信宿的开销。
·定时器：路由项最后一次被修改的时间。
·路由标记：区分路由为内部路由协议的路由还是外部路由协议的路由的标记。
数据库由与系统直接相连的实体的描述初始化，通过从相邻路由器受到的报文修改维护。
路由器间交换的最重要的信息是修改报文，参加路由维护计划的路由器发送当前存在于实体的描述路由数据库的路由修改报文。
仅通过相邻路由器间交换路由信息是可以维护整个系统的最佳路由的，这在接下来的讨论中会逐步得到证实。
距离向量算法总是基于一个这样的事实：路由数据库中的路由已是目前通过报文交换而得到的最佳路由。同时，报文交换仅限于相邻的实体间，也就是说，实体共享同一个网络。
当然，要定义路由是最佳的，就必须有衡量的办法，这就用到前面所说的“metric”。RIP简单的网络中，通常用可行路由所经的路由器数简单地计算metric值。在复杂的网络中，metric一般代表该路由传输数据报的延迟或其它发送开销。 令D(i,j)代表从实体i到实体j的最佳路由的metric值，d（i，j）代表从i直接到j的开销，因为开销是可加的，算法中最佳路由如此获取表示：
D（i，i）=0， 对所有的i
D（i，j）=MIN[d（i，k）+D（k，j）]， 当i不等于k时
实体i从相邻路由器k收到k到j的开销的估计D(k，j)，i将D（k，j）加上i到k的开销估计d（i，k），i比较从所有相邻路由器得到的数值，取得最小数，就得到了它到j的最佳路由。

I. java 最短路径算法 如何实现有向 任意两点的最短路径

Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。

Dijkstra一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表方式
用OPEN,CLOSE表的方式，其采用的是贪心法的算法策略，大概过程如下：
1.声明两个集合，open和close，open用于存储未遍历的节点，close用来存储已遍历的节点
2.初始阶段，将初始节点放入close，其他所有节点放入open
3.以初始节点为中心向外一层层遍历，获取离指定节点最近的子节点放入close并从新计算路径，直至close包含所有子节点

代码实例如下：
Node对象用于封装节点信息，包括名字和子节点
[java] view plain
public class Node {
private String name;
private Map<Node,Integer> child=new HashMap<Node,Integer>();
public Node(String name){
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Map<Node, Integer> getChild() {
return child;
}
public void setChild(Map<Node, Integer> child) {
this.child = child;
}
}

MapBuilder用于初始化数据源，返回图的起始节点
[java] view plain
public class MapBuilder {
public Node build(Set<Node> open, Set<Node> close){
Node nodeA=new Node("A");
Node nodeB=new Node("B");
Node nodeC=new Node("C");
Node nodeD=new Node("D");
Node nodeE=new Node("E");
Node nodeF=new Node("F");
Node nodeG=new Node("G");
Node nodeH=new Node("H");
nodeA.getChild().put(nodeB, 1);
nodeA.getChild().put(nodeC, 1);
nodeA.getChild().put(nodeD, 4);
nodeA.getChild().put(nodeG, 5);
nodeA.getChild().put(nodeF, 2);
nodeB.getChild().put(nodeA, 1);
nodeB.getChild().put(nodeF, 2);
nodeB.getChild().put(nodeH, 4);
nodeC.getChild().put(nodeA, 1);
nodeC.getChild().put(nodeG, 3);
nodeD.getChild().put(nodeA, 4);
nodeD.getChild().put(nodeE, 1);
nodeE.getChild().put(nodeD, 1);
nodeE.getChild().put(nodeF, 1);
nodeF.getChild().put(nodeE, 1);
nodeF.getChild().put(nodeB, 2);
nodeF.getChild().put(nodeA, 2);
nodeG.getChild().put(nodeC, 3);
nodeG.getChild().put(nodeA, 5);
nodeG.getChild().put(nodeH, 1);
nodeH.getChild().put(nodeB, 4);
nodeH.getChild().put(nodeG, 1);
open.add(nodeB);
open.add(nodeC);
open.add(nodeD);
open.add(nodeE);
open.add(nodeF);
open.add(nodeG);
open.add(nodeH);
close.add(nodeA);
return nodeA;
}
}
图的结构如下图所示：

Dijkstra对象用于计算起始节点到所有其他节点的最短路径
[java] view plain
public class Dijkstra {
Set<Node> open=new HashSet<Node>();
Set<Node> close=new HashSet<Node>();
Map<String,Integer> path=new HashMap<String,Integer>();//封装路径距离
Map<String,String> pathInfo=new HashMap<String,String>();//封装路径信息
public Node init(){
//初始路径,因没有A->E这条路径,所以path(E)设置为Integer.MAX_VALUE
path.put("B", 1);
pathInfo.put("B", "A->B");
path.put("C", 1);
pathInfo.put("C", "A->C");
path.put("D", 4);
pathInfo.put("D", "A->D");
path.put("E", Integer.MAX_VALUE);
pathInfo.put("E", "A");
path.put("F", 2);
pathInfo.put("F", "A->F");
path.put("G", 5);
pathInfo.put("G", "A->G");
path.put("H", Integer.MAX_VALUE);
pathInfo.put("H", "A");
//将初始节点放入close,其他节点放入open
Node start=new MapBuilder().build(open,close);
return start;
}
public void computePath(Node start){
Node nearest=getShortestPath(start);//取距离start节点最近的子节点,放入close
if(nearest==null){
return;
}
close.add(nearest);
open.remove(nearest);
Map<Node,Integer> childs=nearest.getChild();
for(Node child:childs.keySet()){
if(open.contains(child)){//如果子节点在open中
Integer newCompute=path.get(nearest.getName())+childs.get(child);
if(path.get(child.getName())>newCompute){//之前设置的距离大于新计算出来的距离
path.put(child.getName(), newCompute);
pathInfo.put(child.getName(), pathInfo.get(nearest.getName())+"->"+child.getName());
}
}
}
computePath(start);//重复执行自己,确保所有子节点被遍历
computePath(nearest);//向外一层层递归,直至所有顶点被遍历
}
public void printPathInfo(){
Set<Map.Entry<String, String>> pathInfos=pathInfo.entrySet();
for(Map.Entry<String, String> pathInfo:pathInfos){
System.out.println(pathInfo.getKey()+":"+pathInfo.getValue());
}
}
/**
* 获取与node最近的子节点
*/
private Node getShortestPath(Node node){
Node res=null;
int minDis=Integer.MAX_VALUE;
Map<Node,Integer> childs=node.getChild();
for(Node child:childs.keySet()){
if(open.contains(child)){
int distance=childs.get(child);
if(distance<minDis){
minDis=distance;
res=child;
}
}
}
return res;
}
}

Main用于测试Dijkstra对象
[java] view plain
public class Main {
public static void main(String[] args) {
Dijkstra test=new Dijkstra();
Node start=test.init();
test.computePath(start);
test.printPathInfo();
}
}