生成树结构各点之间最短路径算法 （本机路由表计算）(JAVA,Python)
先说二叉树，就是一个树形结构，每个点和两个点连接，越往下数量越多，形状看起来就像一棵树一样，故得名二叉树，二叉树用于数据结构可以快速搜索，节约资源提高效率。 每两点之间只有一条路径，无需计算，当然用下述算法一样可以计算的出来，在蛋疼的情况下。
二叉树图：
再说多叉树，二叉树变种，顾名思义，每个点可以和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 现在来说说如果路径信息变了要怎么样。
路径信息变了，简单一句话，把整个路由表删了，重新计算，这就是所谓的更新路由表。
因为一旦更新路径，计算机不可能直接就看出来哪更新了，算哪个点就行了，他还是一样要所有的都看一遍，既然看了，和重新计算已无任何区别，那就直接把所有的删了就行了。 用路由表的时候，要去哪个终点了，算哪个，算完存起来，下次用直接跳存储的信息就行，不用就不管，扔那，这样如果一次还没有全部目的地传输一遍的时候，更新路径信息了，那些没用过的压根就没计算过，也不需要计算，可以节省一部分计算机资源。
