生成树结构各点之间最短路径算法（本机路由表计算）(JAVA,Python)

最新推荐文章于 2022-06-04 19:51:07 发布

ajwr57704

最新推荐文章于 2022-06-04 19:51:07 发布

阅读量422

点赞数

文章标签： python java ui

原文链接：http://www.cnblogs.com/kevinGuo/archive/2011/12/07/2278702.html

版权

先说二叉树，就是一个树形结构，每个点和两个点连接，越往下数量越多，形状看起来就像一棵树一样，故得名二叉树，二叉树用于数据结构可以快速搜索，节约资源提高效率。每两点之间只有一条路径，无需计算，当然用下述算法一样可以计算的出来，在蛋疼的情况下。

二叉树图：

再说多叉树，二叉树变种，顾名思义，每个点可以和N个点相连罢了。同样，每两点之间只有一条路径，无需计算，当然用下述算法一样可以计算的出来，也是在极其蛋疼的情况下。

如图：

生成树 就是多叉树的变种，每一个点都和N个点连接上下左右都无所谓乱七八糟一团最后结果就是随便断一个点其他各点之间还是有路径可以相连的

如图：

此图属于最小生成树，线程情况可能极其混乱与复杂，放一张我用来测试的图，不完全属于生成树，介于多叉与生成之间

再说下路由表的概念，现实网络结构就类似于上面这张测试图，要把信息从一台机器上发送到另一台机器上，就要找到一条最短路径（当然现实情况还有许多突发情况需要考虑，这只是最基本的情况）。其实我觉得吧，干嘛非要自己机器上计算，光存个路由表就得占多大空间去了，就每次需要发送给别人信息的情况下，找自己相邻节点问他们去最终目的地的路径cost，选个最小的发过去完事了，每个人都问下一步要，最后总是能要到最终目的地的，而且本机只需要知道的是下一跳是谁就行，完全不需要保存整个路由信息。

那么，既然非要在本机上计算，那就算给丫看。

思想一样，一步一步问下面要下去。

（代码后面有添加路径信息和删除路由信息时候的计算原则）

首先：咱得先把所有的路径信息描述出来对吧，总不能扔给计算机一张图让人家自己看去吧（没准以后技术发展发展就真可以了）

用语句描述起来的话，简单点说，就是一个点*相邻的另一个点*他们之间的cost

例如此图：假设每两点间cost是1

A*B*1

A*C*1

因为是双向连接所以还需要

B*A*1

C*A*1

所以此算法如果存在单向连接一样可以计算

把这些连接信息存进一个string数组中

例如：String[] s = {"A*B*1", "B*A*1", "B*A*1", "C*A*1"}

顺序无所谓，do what ever you want!

第二步，重点来了，就用上面说的那个思想，从头开始一步一步找下去，每一个点都问他直接连接的所有点（当然要除了问他的那个点）：你去最终目的地要多少个cost，最后的结果就是从终点那一步，一步一步往前计算下去，最小的留下，其他的扔掉。典型迭代思想。一个迭代全部搞定

先把string[] 搞成一个list,方便下面使用

有一点需要注意的是：IMPORTANT!!! 有可能会出现重复

像下面这个情况：A要去E的最短路径

A问B要，B问C要,C问D要，D可能又去问B要了

所以另外还需要一个list去储存已经路过的点了，每次找都永远不回头，只要前面出现过就不回去

不怕这一次找到不一定是最短的，最后综合起来以后肯定是最短的，因为最终是每条路都会走一次

OK，看算法吧，传进来一个list(储存所有路径信息的) 一个点（自己）一个目点计算出下一跳的点（也包括所话费的cost）。

当然这个算法不是最优的，会有重复的计算，会最短路径选择第一次找到那个（应该搞成随机的，这样不会每次去那个点都走这条路，让别的路也来分担一下）

仅供参考，欢迎交流

JAVA版：

（Vector就是list）

Java

 1 public class FindNextRout {
 2 
 3 private Vector al;
 4 private String sourcePort;
 5 private String destPort;
 6 private String nextPort;
 7 
 8 public FindNextRout(Vector al, String sourcePort, String destPort) {
 9 this.al = al;
10 this.sourcePort = sourcePort;
11 this.destPort = destPort;
12 NextRout();
13 }
14 
15 public String getNextPort() {
16 return nextPort;
17 }
18 
19 public void NextRout() {
20 int a = -1;
21 String rout = "";
22 for (Object item : al) {
23 ArrayList all = new ArrayList();
24 String[] ss = (item + "").split("\\*");
25 all.add(ss[0]);
26 if (sourcePort.equals(ss[0])) {
27 if (ss[1].equals(destPort)) {
28 int b = Integer.parseInt(ss[2]);
29 if (b < a || a == -1) {
30 a = b;
31 nextPort = ss[1];
32 }
33 } else {
34 int b = getLeastCost(all, ss[1], destPort);
35 int c = b + Integer.parseInt(ss[2]);
36 if (b != -1) {
37 if (a == -1) {
38 a = c;
39 nextPort = ss[1];
40 } else {
41 if (c < a) {
42 a = c;
43 nextPort = ss[1];
44 }
45 }
46 }
47 }
48 }
49 }
50 
51 }
52 
53 public int getLeastCost(ArrayList all, String sourcePort, String destPort) {
54 int a = -1;
55 if (!all.contains(sourcePort)) {
56 all.add(sourcePort);
57 for (Object item : al) {
58 String[] ss = (item + "").split("\\*");
59 if (sourcePort.equals(ss[0])) {
60 if (!all.contains(ss[1])) {
61 if (ss[1].equals(destPort)) {
62 int b = Integer.parseInt(ss[2]);
63 if (b < a || a == -1) {
64 a = b;
65 }
66 } else {
67 int b = getLeastCost(all, ss[1], destPort);
68 int c = b + Integer.parseInt(ss[2]);
69 if (b != -1) {
70 if (a == -1) {
71 a = c;
72 } else {
73 if (c < a) {
74 a = c;
75 }
76 }
77 }
78 
79 }
80 }
81 }
82 }
83 
84 }
85 return a;
86 
87 
88 }
89 }

Python版：（感谢张东方同学帮忙翻译成Python的）

Python

 1 import os,sys
 2 from Tool import *
 3 
 4 class FindNextAddress:
 5 
 6 def __init__(self,destAddress,UI):
 7 try:
 8 self.nextAddress=UI.routeTable[destAddress]
 9 #check whether the address is in the routeTable
10 
11 #UI.addline('try')
12 except:
13 #UI.addline('ex1')
14 self.UI=UI
15 self.sourceAddress=UI.address
16 self.destAddress=destAddress
17 self.tool=tool()
18 #UI.addline(destAddress)
19 #UI.addline('ex2')
20 self.nextAddress=self.findNextAddress()
21 #if the address is not in the routeTable, recalculate the route.
22 #UI.addline(self.nextAddress)
23 #UI.addline('ex3')
24 
25 def getNextAddress(self):
26 return self.nextAddress
27 
28 #find the next address from the source to the destination
29 def findNextAddress(self):
30 a=-1
31 tempNextAddress=''
32 for item in self.UI.routeInfo:
33 #self.UI.addline(item+"  ITEM")
34 alreadyPass=[]
35 result=item.split('*')
36 self.tool.addItemInList(alreadyPass,result[0])
37 if self.sourceAddress==result[0]:
38 if result[1]==self.destAddress:
39 b=int(result[2])
40 if b<a or a==-1:
41 a=b
42 tempNextAddress=result[1]
43 else:
44 b=self.getLeastCost(alreadyPass,result[1],self.destAddress)
45 c=b+int(result[2])
46 if b != -1:
47 if a==-1:
48 a=c
49 tempNextAddress=result[1]
50 else:
51 if c<a:
52 a=c
53 tempNextAddress=result[1]
54 return tempNextAddress
55 
56 #get to the most appropriate path
57 def getLeastCost(self,alreadyPass,sourceAddress,destAddress):
58 a=-1
59 judge=self.tool.search(alreadyPass,sourceAddress)
60 if judge==False:
61 self.tool.addItemInList(alreadyPass,sourceAddress)
62 for item in self.UI.routeInfo:
63 result=item.split('*')
64 if sourceAddress==result[0]:
65 judgement=self.tool.search(alreadyPass,result[1])
66 if judgement==False:
67 if result[1]==destAddress:
68 b=int(result[2])
69 if b<a or a==-1:
70 a=b
71 else:
72 b=self.getLeastCost(alreadyPass,result[1],destAddress)
73 c=b+int(result[2])
74 if b!=-1:
75 if a==-1 or c<a:
76 a=c
77 return a

OK 现在来说说如果路径信息变了要怎么样。

路径信息变了，简单一句话，把整个路由表删了，重新计算，这就是所谓的更新路由表。

因为一旦更新路径，计算机不可能直接就看出来哪更新了，算哪个点就行了，他还是一样要所有的都看一遍，既然看了，和重新计算已无任何区别，那就直接把所有的删了就行了。用路由表的时候，要去哪个终点了，算哪个，算完存起来，下次用直接跳存储的信息就行，不用就不管，扔那，这样如果一次还没有全部目的地传输一遍的时候，更新路径信息了，那些没用过的压根就没计算过，也不需要计算，可以节省一部分计算机资源。

转载于:https://www.cnblogs.com/kevinGuo/archive/2011/12/07/2278702.html

ajwr57704

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
生成树结构各点之间最短路径算法（本机路由表计算）(JAVA,Python)

先说二叉树，就是一个树形结构，每个点和两个点连接，越往下数量越多，形状看起来就像一棵树一样，故得名二叉树，二叉树用于数据结构可以快速搜索，节约资源提高效率。每两点之间只有一条路径，无需计算，当然用下述算法一样可以计算的出来，在蛋疼的情况下。二叉树图：再说多叉树，二叉树变种，顾名思义，每个点可以和N个点相连罢了。同样，每两点之间只有一条路径，无需计算，当然用下述...
复制链接

扫一扫