编程实现路由算法-计算机网络

• 实验目的

运用各种编程语言实现基于Dijkstra算法的路由软件

• 实验内容

本次实验利用课后的作业题实现：

利用path.txt来实现图的各个边的三元组存储：

• 实验过程

利用python中的networkk中的函数add_edge()来实现边的输入和图的构建：

1. def init(G):  
2.     data = []  
3.     for line in open("path.txt","r"):  
4.         data.append(line.strip('\n'))  
5.     for row in data:  
6.         row=row.split(',')  
7.         G.add_edge(eval(row[0]), eval(row[1]), weight=eval(row[2]))  
8.     return G  

算法实现流程：

代码：

1. import networkx as nx  
2.   
3. def init(G):  
4.     data = []  
5.     for line in open("path.txt","r"):  
6.         data.append(line.strip('\n'))  
7.     for row in data:  
8.         row=row.split(',')  
9.         G.add_edge(eval(row[0]), eval(row[1]), weight=eval(row[2]))  
10.     return G  
11.   
12. def Dijkstra(G,start,end):  
13.     RG = G.reverse()  
14.     dist = {}  
15.     previous = {}  
16.     for v in RG.nodes():  
17.         dist[v] = float('inf')  
18.         previous[v] = 'none'  
19.     dist[end] = 0  
20.     u = end  
21.     while u!=start:  
22.         u = min(dist,key=dist.get)  
23.         distu = dist[u]  
24.         del dist[u]  
25.         for u,v in RG.edges(u):  
26.             if v in dist:  
27.                 alt = distu + RG[u][v]['weight']  
28.                 if alt < dist[v]:  
29.                     dist[v] = alt  
30.                     previous[v] = u  
31.     path = [start]  
32.     last= start  
33.     while last != end:  
34.         nxt = previous[last]  
35.         path.append(nxt)  
36.         last = nxt  
37.     return path[::-1]  # 反转路径  
38.   
39. if __name__=="__main__":  
40.     G=nx.DiGraph()  
41.     G=init(G)  
42.     start_node = 1  
43.     end_node = 7  
44.     print("start:",start_node,"to end:",end_node)  
45.     path=Dijkstra(G,start_node,end_node)  
46.     answer=nx.dijkstra_path(G,source=start_node,target=end_node)  
47.     print("dijkstra_path:")  
48.     for i in range(len(answer)-1):  
49.          print(str(answer[i])+'->',end="")  
50.     print(answer[i+1])  

• 实验结果

起点1到终点7的最短路径：

手动计算的结果也与程序得出的结果相同，可见其正确性。

• 心得

Dijkstra算法是非常经典的求最短路径的算法，在离散数学和数据结构中反复学习不是没有意义的，在路由算法中就用到了。但Dijkstra算法在路由算法中并不是最优解，因为可能会出现振荡。还有很多优化的算法。

本次实验中，对Dijkstra算法进行了编程复现，对算法有了更深入的理解。