//modifyshortestr[j]andRL[j]
RL[k]=min+arcs[v][k];
updateRouteLen（R[k],R[v],k,vexnum）;
}//if
}//for
delete[]visit;
visit=NULL;
}//Dijkstra
完成核心算法后，对于每个路由器运行一次Dijkstra算法就可以计算出该路由到其他各个路由的最短路径。
四、实验过程及结果
本实验用6个节点进行模拟，首先输入节点个数，再依次输入节点的标识符和到邻居节点的标识符和距离。
以end为结束符。
运行结果如下：
请输入路由节点总个数：
6
请输入路由节点标识符：
a
请输入节点：
a的邻居节点的标识符及其到邻居节点的距离：
b
8
请输入节点：
a的邻居节点的标识符及其到邻居节点的距离：
f
3
请输入节点：
a的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
b
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
a
8
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
c
3
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
f
5
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
d
2
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
e
4
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
c
请输入节点：
c的邻居节点的标识符及其到邻居节点的距离：
b
3
请输入节点：
c的邻居节点的标识符及其到邻居节点的距离：
d
10
请输入节点：
c的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
d
请输入节点：
d的邻居节点的标识符及其到邻居节点的距离：
c
10
请输入节点：
d的邻居节点的标识符及其到邻居节点的距离：
b
2
请输入节点：
d的邻居节点的标识符及其到邻居节点的距离：
e
6
请输入节点：
d的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
e
请输入节点：
e的邻居节点的标识符及其到邻居节点的距离：
b
4
请输入节点：
e的邻居节点的标识符及其到邻居节点的距离：
d
6
请输入节点：
e的邻居节点的标识符及其到邻居节点的距离：
f
4
请输入节点：
e的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
f
请输入节点：
f的邻居节点的标识符及其到邻居节点的距离：
a
3
请输入节点：
f的邻居节点的标识符及其到邻居节点的距离：
b
5
请输入节点：
f的邻居节点的标识符及其到邻居节点的距离：
e
4
请输入节点：
f的邻居节点的标识符及其到邻居节点的距离：
End
路由表结果
五、实验心得
本次实验，主要的就是一个著名算法的运用，当然通过本次实验我对链路路由算法也有了进一步的认识与了解。
从这次的实验中我不但学会了一个新的算法，进一步锻炼了我的编程能力而且我也对路由相关内容有了更深刻的了解。
六、附录：
源代码
packagedstverctor;
/**
*描述两个路由节点之间关系的类
*
*/
publicclassDistanceNode{
//publicRouteNodesrc;//源节点
//publicDistanceNode（RouteNodesrc）{
//this.src=src;
//}
publicStringdst;//目标节点
publicintdistance;//两者之间的距离
publicStringpath;//经过的第一个路径节点，即线路
publicDistanceNodenext;//下一个节点
publicDistanceNode（）{
}
publicDistanceNode（Stringdst,intdistance,Stringpath）{
this.dst=dst;
this.distance=distance;
this.path=path;
}
/**
*根据节点标识符，得到路由节点到指定节点的距离
*@paramkey指定节点标识符
*@return如果找到，则返回这个关系类节点，否则返回null。
*int
*/
publicDistanceNodefindNode（Stringkey）{
DistanceNodedn=this;
while（dn!
=null）{
if（dn.dst.equals（key））{
returndn;
}
dn=dn.next;
}
returnnull;
}
/**
*根据key向链表中修改或增加一个节点，如果存在dst.equal（key）的点并且他的distance大于要插入的distance，则更改其distance，否则向链表末尾插入新节点
*@paramkey
*@paramdistance
*@parampath
*void
*/
publicvoidaddNode（Stringkey,intdistance,Stringpath）{
DistanceNodedn=findNode（key）;
if（null!
=dn）{//如果找到了节点
if（dn.distance>distance）
dn.distance=distance;
}else{
DistanceNodedn1=this;
while（dn1.next!
=null）{
dn1=dn1.next;
}
DistanceNodenode=newDistanceNode（）;
node.distance=distance;
node.dst=key;
node.path=path;
dn1.next=node;
node.next=null;
}
}
publicvoidprint（）{
DistanceNodedn=this;
System.out.println（"目地节点：
"+dn.dst+"距离：
"+dn.distance+"线路：
"+dn.path）;
while（dn.next!
=null）{
dn=dn.next;
System.out.println（"目地节点：
"+dn.dst+"距离：
"+dn.distance+"线路：
"+dn.path）;
}
}
}
packagedstverctor;
/**
*描述两个路由节点之间关系的类
*
*/
publicclassDistanceNode{
//publicRouteNodesrc;//源节点
//publicDistanceNode（RouteNodesrc）{
//this.src=src;
//}
publicStringdst;//目标节点
publicintdistance;//两者之间的距离
publicStringpath;//经过的第一个路径节点，即线路
publicDistanceNodenext;//下一个节点
publicDistanceNode（）{
}
publicDistanceNode（Stringdst,intdistance,Stringpath）{
this.dst=dst;
this.distance=distance;
this.path=path;
}
/**
*根据节点标识符，得到路由节点到指定节点的距离
*@paramkey指定节点标识符
*@return如果找到，则返回这个关系类节点，否则返回null。
*int
*/
publicDistanceNodefindNode（Stringkey）{
DistanceNodedn=this;
while（dn!
=null）{
if（dn.dst.equals（key））{
returndn;
}
dn=dn.next;
}
returnnull;
}
/**
*根据key向链表中修改或增加一个节点，如果存在dst.equal（key）的点并且他的distance大于要插入的distance，则更改其distance，否则向链表末尾插入新节点
*@paramkey
*@paramdistance
*@parampath
*void
*/
publicvoidaddNode（Stringkey,intdistance,Stringpath）{
DistanceNodedn=findNode（key）;
if（null!
=dn）{//如果找到了节点
if（dn.distance>distance）
dn.distance=distance;
}else{
DistanceNodedn1=this;
while（dn1.next!
=null）{
dn1=dn1.next;
}
DistanceNodenode=newDistanceNode（）;
node.distance=distance;
node.dst=key;
node.path=path;
dn1.next=node;
node.next=null;
}
}
publicvoidprint（）{
DistanceNodedn=this;
System.out.println（"目地节点：
"+dn.dst+"距离：
"+dn.distance+"线路：
"+dn.path）;
while（dn.next!
=null）{
dn=dn.next;
System.out.println（"目地节点：
"+dn.dst+"距离：
"+dn.distance+"线路：
"+dn.path）;
}
}
}
packagedstverctor;
/**
*路由的唯一标识符类
*
*/
publicclassRouteKey{
Stringkey;//路由节点的唯一标识符
RouteKeynext;//路由表中的下一个路由节点
publicRouteKey（）{
}
publicRouteKey（Stringkey）{
this.key=key;
}
publicvoidprint（）{
RouteKeyrk=this;
System.out.print（rk.key+"||"）;
while（rk.next!
=null）{
rk=rk.next;
System.out.print（rk.key+"||"）;
}
}
}
packagedstverctor;
/**
*路由节点
*/
publicclassRouteNode{
DistanceNodeold;//老路由表
DistanceNodecurrent;//新路由表
RouteKeyneighbour;//存储邻居节点的链表头结点
Stringkey;
//跟新路由表
publicvoidupdateCurrent（）{
saveCurrent（）;//路由表变化前保存当前的路由表
RouteNodenb;//邻居节点
RouteKeyrk=neighbour;
while（null!
=rk）{
//System.out.println（"------------"+rk.key+"-------"）;
nb=DistVerctor.map.get（rk.key）;//由节点标记符得到路由节点
//System.out.println（"------------"+nb.key+"-------"）;
DistanceNodedn=nb.old;//得到邻居节点的老路由表
//排除自己在内，避免重新计算自己到邻居节点
if（dn.dst.equals（key））{
System.out.println（"------------"+dn.dst+"------------"）;
dn=dn.next;
}
intdistTonb=0;
if（dn!
=null）
distTonb=current.findNode（nb.key）.distance;//到邻居节点的距离
while（null!
=dn）{
//排除自己在内，避免重新计算自己到邻居节点
if（dn.dst.equals（key））{
System.out.println（"------------"+dn.dst+"------------"）;
dn=dn.next;
}else{
//修改新路由表，
//如果当前节点到dn的距离小于当前节点到邻居节点nb+nb到dn的距离，则修改路由表
//如果不存在当前节点到dn的路径，则在路由表最后新添加该路径
current.addNode（dn.dst,dn.distance+distTonb,nb.key）;
dn=dn.next;
}
}
rk=rk.next;//指向下一个邻居节点
}
}
/**
*将当前表保存为旧表
*
*void
*/
publicvoidsaveCurrent（）{
DistanceNodecnode=current;
DistanceNodeonode=newDistanceNode（）;
copy（cnode,onode）;//得到cnode的备份
old=onode;
while（cnode.next!
=null）{
onode.next=newDistanceNode（）;
copy（cnode.next,onode.next）;
cnode=cnode.next;
onode=onode.next;
}
}
publicvoidcopy（DistanceNodesrc,DistanceNodedst）{
dst.distance=src.distance;
dst.dst=src.dst;
dst.path=src.path;
}
publicvoidprint（）{
System.out.println（key+"的邻居节点：
"）;
neighbour.print（）;
System.out.println（"老路由表：
"）;
old.print（）;
System.out.println（"新路由表：
"）;
current.print（）;
}
}
WelcomeTo
Download!
!
!
欢迎您的下载，资料仅供参考！
升级会员 