中南大学计算机网络实验报告.docx

上传人:b****2 文档编号:24204227 上传时间:2023-05-25 格式:DOCX 页数:21 大小:54KB
下载 相关 举报
中南大学计算机网络实验报告.docx_第1页
第1页 / 共21页
中南大学计算机网络实验报告.docx_第2页
第2页 / 共21页
中南大学计算机网络实验报告.docx_第3页
第3页 / 共21页
中南大学计算机网络实验报告.docx_第4页
第4页 / 共21页
中南大学计算机网络实验报告.docx_第5页
第5页 / 共21页
点击查看更多>>
下载资源
资源描述

中南大学计算机网络实验报告.docx

《中南大学计算机网络实验报告.docx》由会员分享,可在线阅读,更多相关《中南大学计算机网络实验报告.docx(21页珍藏版)》请在冰豆网上搜索。

中南大学计算机网络实验报告.docx

中南大学计算机网络实验报告

 

中 南大 学

 

《计算机网络》实验报告

 

学生姓名      

学  号         

专业班级       

指导教师     桂劲松      

学  院   信息科学与工程学院  

完成时间     2011年1月  

模拟路由算法的实现

一、实验内容

1.模拟距离向量路由算法的路由表交换过程,演示每轮交换后路由表的变化。

2.实现链路状态路由算法中的最短路径算法。

二、实验目的及要求

本实验是计算机网络课程的实践性锻炼环节。

通过实验,帮助学生更好地掌握网络通信协议的实现技术,锻炼学生应用高级编程语言完成通信编程的能力,使学生加深对网络协议本质的理解,巩固课堂所学的理论知识。

要求实验者利用路由选择算法模拟软件提供的通信功能,模拟链路状态路由选择算法的初始化、路由信息扩散过程和路由计算方法;

掌握链路状态算法的路由信息扩散过程;

掌握链路状态算法的路由计算方法。

三、实验原理

编程语言:

JAVA

编程工具:

 MyEclipse

实验实现方式:

单机模拟实现

核心方法:

dijkstra算法计算最短路径

分析:

布置好各个模拟路由,以及路由的路程权值如何获取。

接着就是核心算法的实现,如何计算任意两个路由之间的最短路径问题。

用到的是dijkstra算法。

Dijkstra算法按照从给定起点到图中顶点的距离,顺序求出最短的路径,首先,它求出从起点到最接近起点的顶点之间的最短路径,然后求出第二近的,一次类推,推而广之,再第i次迭代开始之前,算法已经确定了i-1条连接起点和离起点最近顶点之间的最短路径。

这些顶点、起点和从起点到顶点的路径上的边,构成了给定图的一颗子树Ti,因为所有边的权值都是非负数,可以从与Ti的顶点相邻的顶点中找到下一个和起点最接近的顶点。

和Ti的顶点相邻的顶点的集合称为“边缘顶点”,以他们为候选对象,Dijkstra算法可以从中选出一个最接近起点的顶点。

为了确定第I个最接近的顶点,对于每一个边缘顶点u,该算法求出它到最近的树中顶点v的距离以及从起点到v得最短路径长度dv的和,再从中选出具有最小和的顶点。

此次实验主要是运用路由算法来处理路由当中的一些问题,利用Dijkstra算法处理最短路径的问题,在实验中这点已经得到了充分地体现。

下面是该算法的流程图:

 

核心算法代码如下。

其中每个顶点用一个类来封装含有两个属性,一个是路由编号,一个是到某个路由的最短路径初始值为无限大。

voidDijkstra(int*arcs[],int *R[],int RL[],int vexnum){

//迪杰斯特拉算法ﻩ

intv0; //定义源节点

bool*visit=newbool[vexnum];//已经确定最短路径的节点的集合

cout<<"请输入起始节点:

";

cin>>v0;

ﻩcout<<endl;

for(intcnt=0;cnt<vexnum;cnt++){//进行主要的循环之前的初始化

ﻩvisit[cnt]=FALSE;

RL[cnt]=arcs[v0][cnt];

if(RL[cnt]<INFINITY){

ﻩﻩR[cnt][0]=v0;

ﻩﻩﻩR[cnt][1]=cnt;

}

ﻩ} //for

ﻩRL[v0]=0;//源节点的标志

ﻩvisit[v0]=TRUE; //初始化已经找到最短路径的点集合

for(inti=1;i

ﻩﻩintmin=INFINITY;

ﻩintv=v0;

ﻩfor(intj=0;j

ﻩﻩif(!

visit[j])

ﻩif(RL[j]<min){

ﻩﻩﻩv=j;

ﻩﻩﻩmin=RL[j];

ﻩﻩﻩ}

ﻩvisit[v]=TRUE; //离v0顶点最近的v加入到s集

ﻩfor(intk=0;k

ﻩﻩif(!

visit[k]&&(min+arcs[v][k]<RL[k])){

ﻩﻩﻩ//modifyshortestr[j]and RL[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的邻居节点的标识符及其到邻居节点的距离:

请输入节点:

a的邻居节点的标识符及其到邻居节点的距离:

f

3

请输入节点:

a的邻居节点的标识符及其到邻居节点的距离:

end

请输入路由节点标识符:

请输入节点:

b 的邻居节点的标识符及其到邻居节点的距离:

8

请输入节点:

b的邻居节点的标识符及其到邻居节点的距离:

3

请输入节点:

b 的邻居节点的标识符及其到邻居节点的距离:

f

请输入节点:

b的邻居节点的标识符及其到邻居节点的距离:

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的邻居节点的标识符及其到邻居节点的距离:

4

请输入节点:

e的邻居节点的标识符及其到邻居节点的距离:

6

请输入节点:

e的邻居节点的标识符及其到邻居节点的距离:

f

4

请输入节点:

e的邻居节点的标识符及其到邻居节点的距离:

end

请输入路由节点标识符:

f

请输入节点:

f的邻居节点的标识符及其到邻居节点的距离:

a

3

请输入节点:

f 的邻居节点的标识符及其到邻居节点的距离:

b

5

请输入节点:

f的邻居节点的标识符及其到邻居节点的距离:

e

4

请输入节点:

f的邻居节点的标识符及其到邻居节点的距离:

End

路由表结果

五、实验心得

本次实验,主要的就是一个著名算法的运用,当然通过本次实验我对链路路由算法也有了进一步的认识与了解。

从这次的实验中我不但学会了一个新的算法,进一步锻炼了我的编程能力而且我也对路由相关内容有了更深刻的了解。

六、附录:

源代码

packagedstverctor;

/**

*描述两个路由节点之间关系的类

*

*/

public classDistanceNode{

ﻩ//publicRouteNodesrc;//源节点

//ﻩpublicDistanceNode(RouteNodesrc){

//this.src =src;

//}

ﻩpublicStringdst;//目标节点

ﻩpublicintdistance;//两者之间的距离

ﻩpublicString path;//经过的第一个路径节点,即线路

publicDistanceNodenext;//下一个节点

ﻩpublicDistanceNode(){

}

publicDistanceNode(Stringdst,intdistance,Stringpath){

ﻩﻩthis.dst = dst;

ﻩthis.distance= distance;

ﻩﻩthis.path=path;

ﻩ/**

ﻩ*根据节点标识符,得到路由节点到指定节点的距离

ﻩ*@paramkey指定节点标识符

*@return如果找到,则返回这个关系类节点,否则返回null。

ﻩ *int 

*/

public DistanceNodefindNode(Stringkey){

ﻩDistanceNode dn=this;

ﻩﻩwhile(dn!

=null){

ﻩif(dn.dst.equals(key)){

ﻩﻩﻩﻩreturndn;

ﻩﻩ}

dn =dn.next;

ﻩ}

ﻩreturnnull;

}

ﻩ/**

*根据key向链表中修改或增加一个节点,如果存在dst.equal(key)的点并且他的distance大于要插入的distance,则更改其distance,否则向链表末尾插入新节点

ﻩ * @paramkey

 *@paramdistance

ﻩ* @param path

*void

ﻩ*/

ﻩpublicvoidaddNode(Stringkey,intdistance,Stringpath){

ﻩDistanceNode dn=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;

ﻩ}

publicvoid print(){

ﻩDistanceNode dn=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);

ﻩ}

ﻩ}

}

package dstverctor;

/**

* 描述两个路由节点之间关系的类

 *

*/

publicclassDistanceNode {

//publicRouteNodesrc;//源节点

//ﻩpublic DistanceNode(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(String key){

ﻩDistanceNodedn=this;

ﻩﻩwhile(dn!

=null){

ﻩﻩif(dn.dst.equals(key)){

ﻩﻩﻩreturndn;

ﻩﻩ}

ﻩdn =dn.next;

ﻩ}

ﻩreturnnull;

}

ﻩ/**

*根据key向链表中修改或增加一个节点,如果存在dst.equal(key)的点并且他的distance大于要插入的distance,则更改其distance,否则向链表末尾插入新节点

 *@paramkey

* @param distance

*@parampath

*void

ﻩ*/

ﻩpublic voidaddNode(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;

}

}

public voidprint(){

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);

ﻩ}

}

package dstverctor;

/**

 *路由的唯一标识符类

*

 */

publicclassRouteKey{

Stringkey;//路由节点的唯一标识符

RouteKeynext;//路由表中的下一个路由节点

public RouteKey(){

ﻩﻩ

ﻩpublicRouteKey(Stringkey){

ﻩthis.key=key;

}

publicvoid print(){

RouteKeyrk = this;

ﻩSystem.out.print(rk.key+"||");

ﻩwhile(rk.next!

=null){

ﻩrk=rk.next;

ﻩﻩSystem.out.print(rk.key+"||");

ﻩ}

ﻩ}

}

packagedstverctor;

/**

 *路由节点

*/

publicclassRouteNode{

ﻩDistanceNode old;//老路由表

ﻩ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;

ﻩﻩ

ﻩﻩ}

ﻩﻩint distTonb=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=new DistanceNode();

ﻩﻩ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,DistanceNode dst){

ﻩ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();

}

}

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置:首页 > 人文社科 > 文学研究

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1