ﻩﻩif（!
viｓｉt[k]＆&（ｍin＋arcｓ[v][k]＜ＲL[ｋ］））{
ﻩﻩﻩ／/modifyshｏrteｓtｒ[j]and RＬ［j]
ﻩﻩﻩRL[k]=mｉn＋aｒcs[v]［k]；
ﻩﻩﻩﻩupｄateRouteLen（R[ｋ］,R［v],k,vｅxｎum）;
ﻩﻩﻩ}//iｆ
}／/fｏr
ﻩｄｅletｅ［］ visit;
ﻩvｉｓit＝NULＬ；
｝//Dijkstｒa
完成核心算法后,对于每个路由器运行一次Dijkstra算法就可以计算出该路由到其他各个路由的最短路径。
四、实验过程及结果
本实验用６个节点进行模拟，首先输入节点个数，再依次输入节点的标识符和到邻居节点的标识符和距离。
以end为结束符。
运行结果如下:
请输入路由节点总个数:
6
请输入路由节点标识符：
a
请输入节点:
a的邻居节点的标识符及其到邻居节点的距离:
ｂ
８
请输入节点:
a的邻居节点的标识符及其到邻居节点的距离：
f
3
请输入节点：
a的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
ｂ
请输入节点:
b 的邻居节点的标识符及其到邻居节点的距离：
ａ
8
请输入节点:
b的邻居节点的标识符及其到邻居节点的距离:
ｃ
3
请输入节点:
b 的邻居节点的标识符及其到邻居节点的距离：
f
５
请输入节点：
b的邻居节点的标识符及其到邻居节点的距离:
ｄ
2
请输入节点:
b的邻居节点的标识符及其到邻居节点的距离：
e
4
请输入节点：
b 的邻居节点的标识符及其到邻居节点的距离：
ｅnd
请输入路由节点标识符：
c
请输入节点:
ｃ的邻居节点的标识符及其到邻居节点的距离：
b
3
请输入节点：
c的邻居节点的标识符及其到邻居节点的距离:
d
10
请输入节点:
c的邻居节点的标识符及其到邻居节点的距离：
end
请输入路由节点标识符：
d
请输入节点：
d的邻居节点的标识符及其到邻居节点的距离:
c
1０
请输入节点：
d 的邻居节点的标识符及其到邻居节点的距离：
b
2
请输入节点:
d的邻居节点的标识符及其到邻居节点的距离:
e
6
请输入节点:
d的邻居节点的标识符及其到邻居节点的距离:
end
请输入路由节点标识符：
e
请输入节点:
e的邻居节点的标识符及其到邻居节点的距离：
ｂ
4
请输入节点：
ｅ的邻居节点的标识符及其到邻居节点的距离:
ｄ
6
请输入节点:
e的邻居节点的标识符及其到邻居节点的距离：
f
4
请输入节点:
e的邻居节点的标识符及其到邻居节点的距离:
end
请输入路由节点标识符：
f
请输入节点:
f的邻居节点的标识符及其到邻居节点的距离:
a
3
请输入节点：
ｆ 的邻居节点的标识符及其到邻居节点的距离:
b
5
请输入节点:
f的邻居节点的标识符及其到邻居节点的距离:
e
4
请输入节点：
f的邻居节点的标识符及其到邻居节点的距离：
Eｎd
路由表结果
五、实验心得
本次实验,主要的就是一个著名算法的运用,当然通过本次实验我对链路路由算法也有了进一步的认识与了解。
从这次的实验中我不但学会了一个新的算法,进一步锻炼了我的编程能力而且我也对路由相关内容有了更深刻的了解。
六、附录：
源代码
pａckagedｓｔvercｔoｒ；
/**
*描述两个路由节点之间关系的类
*
*/
ｐuｂliｃ clａssＤｉｓtaｎｃeNｏde{
ﻩ／/publicRｏuteNｏdesrc；／/源节点
/／ﻩpublicDistancｅＮｏde（ＲoｕteNｏdesrc）{
//ｔhis.src =src;
//}
ﻩpuｂlｉｃSｔriｎgdｓｔ;//目标节点
ﻩｐｕｂlicinｔdistａncｅ;/／两者之间的距离
ﻩｐublicStｒiｎg path；／/经过的第一个路径节点，即线路
ｐuｂｌｉｃDistancｅNodeneｘt；//下一个节点
ﻩ
ﻩｐublｉcＤiｓｔanｃeNode（）{
ﻩ
}
puｂｌｉcDisｔanｃeNode（Strｉngｄｓｔ，intdistance,Stringpath）｛
ﻩﻩthis.dst = ｄst;
ﻩthis.ｄiｓtanｃｅ= diｓｔance;
ﻩﻩthis．patｈ=paｔh;
｝
ﻩ/*＊
ﻩ*根据节点标识符，得到路由节点到指定节点的距离
ﻩ＊@paｒａmｋey指定节点标识符
*@reｔurn如果找到，则返回这个关系类节点,否则返回nuｌl。
ﻩ *ｉnt
*/
puｂliｃ DistaｎcｅNoｄｅｆinｄNoｄe（Stringｋeｙ）{
ﻩDistａnceNｏｄe ｄn=thiｓ;
ﻩﻩwhile（dｎ！
=null）｛
ﻩiｆ（ｄn.dst.eｑuａls（keｙ））{
ﻩﻩﻩﻩretｕrndn;
ﻩﻩ}
dｎ =dｎ.nｅｘt;
ﻩ｝
ﻩretuｒｎnuｌｌ;
}
ﻩ/*＊
*根据kｅy向链表中修改或增加一个节点，如果存在dｓt.equal（key）的点并且他的disｔａnce大于要插入的ｄiｓtａnｃe,则更改其ｄiｓtance,否则向链表末尾插入新节点
ﻩ * @ｐarａｍkey
*@pａrａｍdisｔａnce
ﻩ* @ｐarａm ｐath
*voｉd
ﻩ*/
ﻩpubｌicvｏｉdaddNodｅ（Sｔriｎgｋey,intdistａnｃｅ,Ｓtｒingpaｔh）{
ﻩDistaｎceNoｄｅ ｄｎ=fiｎｄNoｄe（kｅy）；
ﻩｉf（nulｌ！
＝dn）{//如果找到了节点
ﻩif（dn．distancｅ>dｉstance）
ﻩﻩdn.disｔaｎce＝ ｄistancｅ;
}else｛
ﻩﻩﻩＤistanceＮｏdedn1 =thｉs;
ﻩwhｉle（dｎ１.neｘt！
＝null）{
ﻩﻩdn１=ｄn１.next;
ﻩ}
ﻩﻩDｉstanceNodeｎodｅ=neｗDistanｃeNoｄe（）；
ﻩﻩnoｄe．ｄistance=ｄiｓtanｃｅ;
ﻩnodｅ.dst=key;
nodｅ.path= path;
dｎ1.ｎexｔ=node;
ﻩﻩnｏde.neｘt=nｕll;
ﻩ}
｝
ﻩ
publｉcvoid print（）{
ﻩDｉstａnceNode dn＝ｔhｉs;
ﻩSｙstem.out.prｉntln（"目地节点:
"+ｄn.dsｔ+"距离:
"＋dn.ｄistanｃe+" 线路:
＂＋ｄn.path）;
ﻩﻩwhiｌe（dn.next!
=ｎulｌ）{
ﻩﻩﻩdn =dn.neｘｔ;
ﻩﻩSｙｓtｅｍ.out．ｐrintln（"目地节点:
＂＋dn.ｄｓt＋"距离:
＂+dn.ｄｉsｔance＋＂ 线路:
＂+dｎ.paｔh）;
ﻩ}
ﻩ}
}
package dstveｒｃtｏr;
/**
* 描述两个路由节点之间关系的类
*
*/
ｐuｂliｃclassDistａncｅNodｅ {
ﻩ
/／publｉcRouteNｏｄesrｃ;//源节点
//ﻩpｕblic DｉstanceＮode（RoｕtｅNoｄｅsrc）｛
／/ﻩtｈis.src= ｓrｃ;
//}
pｕbliｃSｔringdst;//目标节点
ﻩpublicinｔdｉｓtaｎcｅ；／／两者之间的距离
pubｌicSｔrinｇｐath；//经过的第一个路径节点,即线路
publiｃＤistaｎceNodｅneｘｔ;//下一个节点
ﻩ
ﻩpublicDistanceNｏde（）｛
ﻩ
｝
publｉcDisｔanｃeＮode（Striｎgdｓt,intｄistａｎce,Strinｇpath）{
ﻩthis.dｓt=dsｔ;
ﻩﻩthis.diｓtanｃe= ｄiｓtａnce;
thｉs．paｔｈ ＝path;
}
ﻩ
/**
*根据节点标识符,得到路由节点到指定节点的距离
* @paramkey指定节点标识符
ﻩ*@rｅturｎ 如果找到,则返回这个关系类节点，否则返回ｎull。
ﻩ*int
*/
publiｃDistａnceNｏdefｉndＮodｅ（String ｋey）{
ﻩDｉsｔancｅNodeｄｎ＝ｔｈｉs；
ﻩﻩwｈiｌe（dｎ！
＝nuｌl）{
ﻩﻩif（dn.ｄsｔ.equals（key））{
ﻩﻩﻩrｅtuｒndn;
ﻩﻩ}
ﻩdn ＝dｎ.ｎexｔ;
ﻩ}
ﻩｒetuｒnnull;
}
ﻩ/＊*
*根据keｙ向链表中修改或增加一个节点,如果存在ｄｓt.equal（key）的点并且他的dｉstａｎce大于要插入的distａnｃe,则更改其distanｃe,否则向链表末尾插入新节点
＊@parａｍｋeｙ
* @pａram dｉstancｅ
＊@paraｍｐaｔh
*ｖoiｄ
ﻩ*/
ﻩpuｂliｃ ｖoidadｄNode（Stｒingkeｙ,iｎtdiｓtanｃe，Sｔｒingｐath）{
ﻩﻩDistanceNｏdｅdn=fｉnｄNode（ｋey）;
if（nｕll!
＝ｄｎ）{//如果找到了节点
ﻩﻩif（dn.diｓtaｎce>dｉｓtａｎce）
ﻩｄn.distａｎｃe =ｄisｔaｎｃe;
ﻩ｝ｅlse{
ﻩﻩＤistanｃeNodeｄn1=thｉｓ;
ﻩﻩｗhilｅ（dｎ1.next!
＝ｎull）{
ﻩﻩｄｎ1=dn１.ｎext;
ﻩ}
ﻩDistａncｅＮodeｎｏde＝ nｅｗDiｓtａnceＮｏde（）;
ﻩnodｅ.diｓtanｃe=ｄｉstaｎcｅ；
ﻩﻩﻩｎoｄe.ｄst =key;
ﻩﻩﻩnoｄｅ.pａth=ｐａth;
ﻩﻩdn１．nexｔ=node;
ﻩnode．ｎeｘt＝ｎuｌl;
}
}
ﻩ
ｐｕblic ｖoidprint（）{
DistanceNｏdedn＝tｈis;
ﻩSystem．out.prinｔｌn（＂目地节点：
"+dn.dst+"距离：
"+ｄｎ.ｄisｔａnce+＂ 线路:
＂＋ｄn.pａtｈ）;
ﻩwhilｅ（ｄn.next！
=ｎull）{
ﻩﻩﻩｄｎ=dｎ.nｅxt；
System.oｕt．ｐriｎtln（"目地节点:
"+dn．dst+＂ 距离:
＂＋dn.distance+"线路:
＂+dｎ.pａth）；
ﻩ}
}
｝
pａｃkage ｄstverｃtｏｒ;
/**
*路由的唯一标识符类
*
＊/
pubｌｉccｌassＲoｕtｅＫey{
Sｔrｉngkｅy;/／路由节点的唯一标识符
RｏuteＫeynext;//路由表中的下一个路由节点
public RoｕteKey（）{
ﻩﻩ
｝
ﻩpublicRouteＫey（Strｉｎgkeｙ）{
ﻩtｈiｓ.key=ｋey;
}
ﻩ
ｐuｂlicvoid ｐriｎt（）{
ＲoｕtｅKｅyrk = tｈis;
ﻩSysｔｅｍ.out.ｐrinｔ（ｒk．key＋＂｜|"）;
ﻩｗｈile（rk．next!
=null）{
ﻩｒk=rk.nｅxt;
ﻩﻩSysｔem．out.prinｔ（rk.key+＂｜|"）;
ﻩ}
ﻩ｝
}
packagedstverｃtｏｒ；
/**
*路由节点
*/
pubｌicclassＲouｔeNoｄe{
ﻩＤisｔaｎcｅNｏｄe ｏld;／/老路由表
ﻩDisｔanceNodecurrent;//新路由表
RoｕｔeKeyｎeighｂour;//存储邻居节点的链表头结点
Sｔｒｉｎgｋey；
ﻩ//跟新路由表
ｐｕｂlicｖoidupdateＣuｒｒeｎt（）{
ﻩsaveCuｒrent（）;//路由表变化前保存当前的路由表
ﻩﻩRｏuteＮｏdeｎb;//邻居节点
ﻩRｏuteKeyrk=nｅiｇhbour;
ﻩwｈile（ｎuｌl!
＝rk）{
ﻩﻩ／/Syｓtem．ｏut．println（"---－－----－-－"+rｋ.kｅy＋"－--－--－＂）;
ﻩﻩｎb=DistVerctor.map.get（rk.key）；//由节点标记符得到路由节点
ﻩﻩ//Ｓｙｓtｅm.ｏut.prinｔlｎ（"-－----－-----"＋nb．keｙ＋"－－---－-"）;
ﻩﻩDisｔanceNodedｎ=nb.ｏlｄ；/／得到邻居节点的老路由表
ﻩ//排除自己在内,避免重新计算自己到邻居节点
ﻩﻩiｆ（dn.ｄｓt.equals（kｅy））{ﻩ
ﻩSｙstem.ouｔ.ｐrintｌｎ（"--－---------"+dn.dｓｔ＋＂-－－－-－－-----"）;
ﻩﻩdn＝ ｄn.ｎeｘｔ;
ﻩﻩ
ﻩﻩ｝
ﻩﻩint distTｏnb＝0;
ﻩﻩ
ﻩｉｆ（ｄn!
＝ｎuｌl）
disｔToｎb＝cuｒｒｅnt.fiｎdＮode（nb.kｅy）.ｄistance；/／到邻居节点的距离
ﻩwhile（null!
=ｄn）{
ﻩﻩ//排除自己在内，避免重新计算自己到邻居节点
ﻩﻩif（dn.ｄst.equals（key））｛
ﻩﻩﻩＳyｓtem.out.ｐrintln（＂－-－-------－-＂+dn.ｄst＋"---－--－-----＂）;
ﻩﻩﻩdn=dｎ.next;
ﻩ
ﻩﻩﻩ｝elsｅ{
ﻩﻩﻩ//修改新路由表，
ﻩ/／如果当前节点到dn的距离小于当前节点到邻居节点nb+nb到dn的距离,则修改路由表
ﻩ/／如果不存在当前节点到dｎ的路径，则在路由表最后新添加该路径
ﻩﻩﻩcｕrｒｅｎｔ.aｄdNode（dn.ｄst,dn．diｓｔanｃe+distTonb, nｂ.kｅy）;
ﻩﻩﻩdn＝ dn．nexｔ;
ﻩﻩ}
ﻩ}
rk=rk.neｘt;//指向下一个邻居节点
｝
ﻩ}
／*＊
*将当前表保存为旧表
ﻩ *
ﻩ* vｏid
ﻩ*/
puｂｌicvｏidｓaveCｕrrenｔ（）{
DiｓｔaｎｃｅNodeｃnodｅ=current;
ﻩDistancｅNｏdeoｎode＝ｎeｗ DisｔanｃｅNode（）;
ﻩﻩcopy（ｃnode,onodｅ）;//得到cnｏde的备份
ｏld ＝oｎode;
ﻩﻩwhilｅ（cnode．nexｔ！
=null）{
ﻩﻩonｏｄe．nexｔ=nｅwDistaｎcｅNode（）;
ﻩcoｐｙ（cnｏde．nｅｘt,onodｅ.next）;
ｃnode=cnoｄｅ．nexｔ;
ﻩonode=onode.nｅｘt；
ﻩ}
ﻩ}
pｕｂliｃvoｉdcopｙ（DisｔaｎｃeＮodｅsrc,ＤistanceNodｅ dｓｔ）{
ﻩdst.ｄistance =ｓrc．diｓtaｎｃe;
ﻩdsｔ.dｓｔ = src.dｓt;
ﻩﻩdst.patｈ＝ src.path;
ﻩ}
ﻩpuｂｌicvoidｐrint（）{
ﻩSyｓtem.out.printｌn（kｅy+＂的邻居节点：
"）;
ｎｅiｇhbouｒ.ｐrint（）;
ﻩﻩSystem．oｕｔ.pｒintln（"老路由表:
"）；
ﻩold.prｉnｔ（）;
System.oｕt.pｒintln（"新路由表:
"）;
ﻩﻩcｕrrent．prｉnt（）;
}
}
升级会员 