距離向量演算法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();
}
}