计算机网络距离矢量路由算法实验报告
计算机网络原理 距离矢量路由
计算机网络原理距离矢量路由距离矢量路由选择（Distance Vector Routing）算法是通过每个路由器维护一张表（即一个矢量）来实现的，该表中列出了到达每一个目标地的可知的最短路径及所经过的线路，这些信息通过相邻路由器间交换信息来更新完成。
我们称这张表为路由表，表中按进入子网的节点索引，每个表项包含两个部分，到达目的地最优路径所使用的出线及一个估计的距离或时间，所使用的度量可能是站段数，时间延迟，沿着路径的排队报数或其他。
距离矢量路由选择算法有时候也称为分布式Bellman-Ford路由选择算法和Ford-Fulkerson算法，它们都是根据其开发者的名字来命名的(Bellman，1957；Ford and Fulkerson，1962)。
它最初用于ARPANET路由选择算法，还用于Internet和早期版本的DECnet 和Novell的IPX中，其名字为RIP。
AppleTalk t Cisco路由器使用了改进型的距离矢量协议。
在距离矢量路由选择算法中，每个路由器维护了一张子网中每一个以其他路由器为索引的路由选择表，并且每个路由器对应一个表项。
该表项包含两部分：为了到达该目标路由器而首选使用的输出线路，以及到达该目标路由器的时间估计值或者距离估计值。
所使用的度量可能是站点数，或者是以毫秒计算的延迟，或者是沿着该路径排队的分组数目，或者其他类似的值。
假设路由器知道它到每个相邻路由器的“距离”。
如果所用的度量为站点，那么该距离就为一个站点。
如果所用的度量为队列长度，那么路由器只需检查每一个队列即可。
如果度量值为延迟，则路由器可以直接发送一个特殊的“响应”（ECHO）分组来测出延时，接收者只对它加上时间标记后就尽快送回。
距离矢量路由算法
距离矢量路由算法（Distance Vector Routing，DV）是ARPANET网络上最早使用的路由算法，也称Bellman-Ford路由算法和Ford-Fulkerson算法，主要在RIP（Route Information Protocol）协议中使用。
Cisco的IGRP和EIGRP路由协议也是采用DV这种路由算法的。
“距离矢量路由算法”的基本思想如下：每个路由器维护一个距离矢量（通常是以延时是作变量的）表，然后通过相邻路由器之间的距离矢量通告进行距离矢量表的更新。
每个距离矢量表项包括两部分：到达目的结点的最佳输出线路，和到达目的结点所需时间或距离，通信子网中的其它每个路由器在表中占据一个表项，并作为该表项的索引。
每隔一段时间，路由器会向所有邻居结点发送它到每个目的结点的距离表，同时它也接收每个邻居结点发来的距离表。
这样以此类推，经过一段时间后便可将网络中各路由器所获得的距离矢量信息在各路由器上统一起来，这样各路由器只需要查看这个距离矢量表就可以为不同来源分组找到一条最佳的路由。
现假定用延时作为距离的度量，举一个简单的例子，如图7-37所示。
假设某个时候路由器Y收到其邻居路由器X的距离矢量，其中m是Y估计到达路由器X的延时。
若Y路由器知道它到邻居Z的延时为n，那么它可以得知Z通过Y到达X需要花费时间m+n。
如果Z路由器还有其他相邻路由器，则对于从其他每个邻居那儿收到的距离矢量，该路由器执行同样的计算，最后从中选择费时最小的路由作为Z去往X的最佳路由，然后更新其路由表，并通告给其邻居路由器。
图7-37 距离矢量路由算法简单实例现以一个如图7-38所示的示例介绍距离矢量算法中的路由的确定流程，各段链路的延时均已在图中标注。
A、B、C、D、E代表五个路由器，假设路由表的传递方向为：A → B →C → D → E（这与路由器启动的先后次序有关）。
下面具体的流程。
（1）初始状态下，各路由器都只收集直接相连的链路的延时信息，各路由器结点得出各自的初始矢量表如图7-39所示。
距离矢量路由算法原理实验
距离矢量路由算法原理实验【实验目的】1、要求实验者利用路由选择算法模拟软件提供的通信功能，模拟距离矢量路由选择算法的初始化、路由信息扩散过程和路由计算方法；2、掌握距离矢量算法的路由信息扩散过程；3、掌握距离矢量算法的路由计算方法。
【预备知识】1、路由选择算法的特征、分类和最优化原则2、路由表的内容、用途和用法3、距离矢量算法的基本原理【实验环境】1、分组实验，每组4~10人。
2、拓扑：虚线表示节点之间的逻辑关系，构成一个逻辑上的网状拓扑结构。
3、设备：小组中每人一台计算机。
4、实验软件：路由选择算法模拟软件（routing.exe ）【实验原理】路由选择算法模拟软件根据给定的拓扑结构，为实验者提供基本的本地路由信息，并能发送和接收实验者所组织的路由信息，帮助实验者完成路由选择算法的路由信息扩散过程、路由计算过程和路由测试过程。
1、模拟软件的功能（图2-1）● 在局域网内根据小组名称和成员数量建立一个模拟网络拓扑结构，每个成员模拟拓扑中的一台路由器，路由器上的本地路由信息由实验软件提供。
● 向实验者指定的发送对象发送实验者自行组织的发送内容。
● 提示实验者有数据需要接收，并显示接收内容。
N路由节点2 路由节点N-1 N = 4 ~ 10●为实验者提供记录路由计算结果的窗口——路由表窗口。
●为实验者提供分组逐站转发方法来验证路由选择的结果。
图2-1 路由选择算法模拟软件主界面2、模拟软件的使用方法1）建立小组通过建立小组，每个小组成员可以获得本节点的编号和本地直连链路信息。
a）4～10人一组，在实验前自由组合形成小组。
小组人数尽量多些，每人使用一台计算机。
启动实验软件后点击“建立小组”按钮。
（图2-2）图2-2 选择建立小组b）在建立小组的窗口内填入小组名称和成员数量。
同一小组成员必须填写同样的小组名称和成员数量才能正确建立小组。
（图2-3）图2-3 建立小组窗口图2-4 小组建立过程c）点击“加入”按钮后，实验软件以广播形式将组名广播出去。
基于距离矢量算法的路由器模拟实验
基于距离矢量算法的路由器模拟实验一试验目的深入理解分布式路由选择算法理解、掌握和利用距离向量算法所实现的路由器模拟Internet上的IP路由器，它能确定网络的最短路由，并在其上传输分组二算法描述距离向量算法也称为Bellman-Ford shortest path algorithm 它是一种动态路由选择算法每个路由器都定期与其相邻的所有路由器交换路由表，据此更新它们自己的路由表路由表更新规则:1所有结点都监听从其它结点传来的路由表，并在下列情况下更新其路由表1发现了一条到达某目的的新路由，而该路由在原来的路由表中不存在(即发现了一条新路由)，则在路由表中增加该路由2发现了一条到达某目的的、距离更短的新路由，则用该路由替换原有的路由3到达某目的的一条路由，其后继结点到达该目的地的距离发生了变化，则需要更新该路由的距离三实验要求编写一个程序利用距离向量算法更新路由表该程序的多个实例(进程或线程)可以以运行在一台机器一个实例代表一个路由器(结点)实例之间利用UDP交换路由假设结点与其邻居结点的都为距离为1。
路由表采用如下结构:目的结点(dest_addr) 路由(route)5 3,4,5… …在路由表中，我们登记路由而不是下一跳，以方便处理。
转发分组时，只考虑第一个下一个结点为了指明实例及其邻居，程序启动时必须能接收以下参数:其中: router ID, myport, port1, port2, port3…–ID:实例的编号，数字0,9–myport:该实例使用的UDP端口，以便发送和接收分组–port1, port2, port 3, …:该实例的邻居所使用的UDP端口程序必须能处理以下命令:1)N,打印活动的邻居列表。
–用空格分开代表各个邻居的数字(在一行) –所谓活动邻居是指直接可达的结点(距离为1) –如果没有邻居，则输出空行–例如:4 72)T,输出路由表。
输出到每个目的结点的路由–每条路由一行––例如:4 37 63)0，1，… 9,发送分组–每个数字代表一个数据分组发送请求–数据分组发送到数字代表的目的地–如果目的结点不是邻居结点，不能直接发送分组，而必须在路由的各个结点上沿路由转发该分组4)0，1，… 9,向目的结点发送分组–收到数据分组的结点必须输出一行，显示该分组的目的–例如:发送分组:5转发分组:显示 F5–如果结点无法转发分组，则丢弃该分组，显示:D目的例如: 显示 D5 –数据分组没有数据，只需要目的地址和TTL TTL:Time to Live分组应该在TTL规定的时间或步数内到达目的结点，否则丢弃之分组经过每个中间结点时，将其TTL减1。
计算机网络实验二
福建农林大学金山学院实验报告系（教研室）：信息与机电工程系专业：计算机科学与技术年级：2013 实验课程：计算机网络姓名：王鑫学号：实验室号：_计算机号：实验时间：指导教师签字：成绩：实验2：路由器常用协议配置一、实验目的和要求1.掌握路由器基本配置原理2.理解路由器路由算法原理3.理解路由器路由配置方法二、实验项目内容1.掌握路由器静态路由配置2.掌握路由器RIP动态路由配置3.路由器OSPF动态路由配置三、实验环境1. 硬件：PC机；2. 软件：Windows操作系统、Packet tracer 6.0 。
四、实验原理及实验步骤路由器单臂路由配置(选做)实验目标掌握单臂路由器配置方法；通过单臂路由器实现不同VLAN之间互相通信；实验背景某企业有两个主要部门，技术部和销售部，分处于不同的办公室，为了安全和便于管理对两个部门的主机进行了VLAN的划分，技术部和销售部分处于不同的VLAN。
现由于业务的需求需要销售部和技术部的主机能够相互访问，获得相应的资源，两个部门的交换机通过一台路由器进行了连接。
技术原理单臂路由：是为实现VLAN间通信的三层网络设备路由器，它只需要一个以太网，通过创建子接口可以承担所有VLAN的网关，而在不同的VLAN间转发数据。
实验步骤新建packer tracer拓扑图当交换机设置两个Vlan时，逻辑上已经成为两个网络，广播被隔离了。
两个Vlan的网络要通信，必须通过路由器，如果接入路由器的一个物理端口，则必须有两个子接口分别与两个Vlan对应，同时还要求与路由器相连的交换机的端口fa 0/1要设置为trunk，因为这个接口要通过两个Vlan的数据包。
检查设置情况，应该能够正确的看到Vlan和Trunk信息。
计算机的网关分别指向路由器的子接口。
配置子接口，开启路由器物理接口。
默认封装dot1q协议。
配置路由器子接口IP地址。
实验设备PC 2台；Router_2811 1台；Switch_2960 1台路由器静态路由配置实验目标●掌握静态路由的配置方法和技巧；●掌握通过静态路由方式实现网络的连通性；●熟悉广域网线缆的链接方式；实验背景学校有新旧两个校区，每个校区是一个独立的局域网，为了使新旧校区能够正常相互通讯，共享资源。
距离矢量路由算法原理实验教案
实验3：距离矢量路由算法原理 实验
路由算法原理性实验
目标
要求实验者根据路由选择算法模拟软件提供的功 能，模拟分布式路由选择算法的初始化、路由信 息扩散过程和路由计算方法；
掌握D-V算法的路由信息扩散过程； 掌握D-V算法的路由计算方法。
实验前的准备
填写实验报告中实验原理部分 分组
2
实 验 软 件 主 界 面
3
建立小组
4~10人一组，互相配合，多多益善。 建立小组过程：设置组名和小组人数
4
建立小组：设置组名和成员数
同一小组成员设置的成员数量应一致 设置完成后选择加入，可观察到其他成员加
入的情况
5
小组建立
当成员到达预定数量后，可选择确定完成小 组建立
6
本地信息Biblioteka 小组通过路由更新信息的交互，形成新的路由
15
注意
实验各步骤都需 要进行记录
请翔实、忠实地 记录实验数据
如果路由发生错 误，将小组的记 录数据汇总后， 分析并发现错误 产生的原因。
16
思考题
1、一个路由节点如何判断所使用的路由算法已经收 敛？
2、一个路由节点在路由形成过程中（即路由算法没 有收敛时），应该如何处理收到的数据？为什么？ 假设这些数据的目的都不是这个路由节点。
3、请根据实验记录中的距离矢量路由信息，画出对 应的拓扑图。
4、在距离矢量算法算法的路由测试实验中，被测路 由是否正确？是否都是最短路径？如果不是，原因 是什么？
17
再将更新后的路由表发送给相邻结点 经过多次来回，各结点算出到其它结点的最
短路由
11
测试路由
点击“测试路径”按钮，继续点击“已发送X 份数据按钮”
北邮计算机网络技术实践--实验三
计算机网络技术实践实验报告实验名称 RIP和OSPF路由协议的配置及协议流程姓名__ 17____ 实验日期： 2014年4月11日学号___ _____实验报告日期： 2014年4月12日报告退发： ( 订正、重做 )一.环境（详细说明运行的操作系统，网络平台，网络拓扑图）（1）操作系统：Windows7（2）网络平台：Dynamips环境下的虚拟网络（3）网络拓扑图：6个路由器，3个PC机，11个网段。
(PS:我的学号是511，所以第三个IP为1)二.实验目的✧在上一次实验的基础上实现RIP和OSPF路由协议✧自己设计网络物理拓扑和逻辑网段，并在其上实现RIP和OSPF协议；✧通过debug信息来分析RIP协议的工作过程，并观察配置水平分割和没有配置水平分割两种情况下RIP协议工作过程的变化。
三.实验内容及步骤（包括主要配置流程，重要部分需要截图）（1）改写的.net文件（2）实现RIP和OSPF协议前配置1.运行各个路由器和主机2.完成各个路由器和主机端口配置R1端口：PC1端口：测试连通性：（3）实现RIP协议未配置RIP协议的情况：R1端口配置RIP：测试RIP后路由之间的联通：测试RIP后主机之间的联通：配置RIP协议的情况：Debug信息：R1路由：R2路由：同一自治系统中的路由器每过一段时间会与相邻的路由器交换子讯息，以动态的建立路由表。
RIP 允许最大的跳数为15 多于15跳不可达。
RIP协议根据距离矢量路由算法来完成。
每个路由器都有一个路由表，通过相互传递路由表来更新最新的与其他路由之间的信息。
从上图中R1路由是接收R2传来的信息来更新路由表，而R2是从R5接收信息来更新路由表。
关闭R2水平分割：通过对比关闭之前和之后的R2的debug信息，我们可以发现，在关闭之前，路由器会标记已经收到的信息，不会重复的接收和发出，而关闭之后路由器就在两个路由之间不停的循环发送和接收，照成了不必要操作。
距离矢量_DV_算法分析实验
距离矢量（DV）算法原理
DV算法根据跳数确定路由
子网： 202.112.138.0/24
A
B
C
D
子网：
202.112.130.0/24
2
距离矢量(DV)对网络的描述
A
子网： 202.112.138.0/24
B
子网： 202.112.130.0/24
目的地址 202.112.130.0
2. 在各台计算机上运行Wireshark，观察截取 到的报文。
3. 按照指导书上的步骤对截取的报文进行分析， 理解距离矢量算法的计算过程。
7
下一跳 B
路由器A的路由表
跳数 1
3
路由器收到一条Rip选路信息后的计算过程
每个当路由器收到相邻路由器R发来的一个跳数为 M、目的地址为D的更新消息时，会将收到的路由信息 与自己的路由表进行比较，如果
1. 没有到D这个网段的路由表项存在，则生成路由表项（D、 M+1，R），其中跳数为M+1；
2. 否则，如果已存在（D，*源自R）的路由表项，则更新为（D、 M+1，R）；
E1:192.168.3.1/24
R1
E0/13
Vlan1:192.168.2.1/24
Loop1:
192.168.1.1/24
S1
E0/1 E0/2
Vlan1:192.168.3.2/24 E0/13
S2
E0/1
E0/2
PCA
PCB
PCC
PCD
Ip:192.168.2.10/24 Ip:192.168.2.11/24 Gw:192.168.2.1 Gw:192.168.2.1 Ip:192.168.3.10/24
距离矢量路由协议
距离矢量路由协议
距离矢量路由协议(Distance Vector Routing Protocol）是计算机网络路由协议的一种，它可以在网络上自动计算出一条传输数据包最近的路径，从而提高数据传输速率。
距离矢量路由协议以路由器与其他路由器之间的距离作为参数，根据距离计算出一条最优的数据传输路径。
每个路由器向其他路由器发出“路由器到其他路由器的距离”报文，报文中包含有该路由器对于其他路由器的最优距离。
所有路由器收到此报文后，依据路由器到其他路由器之间的距离，计算出一条最优的传输路径。
这样，数据路由器就能够自动地计算出一条最近的报文传输路径，大大提高了网络通讯的效率。
电子科技大学 计算机网络 实验报告 2017 计算机学院
计算机专业类课程实验报告课程名称：计算机网络学院：计算机科学与工程学院专业：数字媒体技术学生姓名：tss学号：010指导教师：日期：2017年5月21日电子科技大学实验报告实验一一、实验名称：交换机和路由器的基本配置二、实验学时：1三、实验内容和目的：理解和掌握交换机和路由器的工作原理；掌握交换机和路由器命令行各种操作模式的区别；能够使用各种帮助信息，以及用命令进行基本的配置。
四、实验原理：交换机和路由器（以下简称设备）的管理方式基本分为两种：带内管理和带外管理。
通过设备的Console口管理设备属于带外管理，不占用设备的网络接口，其特点是需要使用配置线缆，近距离配置。
第一次配置交换机或路由器时必须利用Console端口进行配置。
交换机或路由器的命令行操作模式，主要包括：用户模式、特权模式、全局配置模式、端口模式等几种。
本次实验学习多种模式之间的切换，以及路由器与交换机的基本配置。
五、实验器材（设备、元器件）Cisco网络设备模拟器六、实验步骤：交换机的配置第一步：交换机各个操作模式直接的切换使用enable进入特权模式，configure terminal进入配置模式第二步：交换机命令行界面基本功能使用可以输出在当前模式下可能的命令第三步：配置交换机的名称和每日提示信息使用banner motd $，可以设置交换机进入时的提示语言。
通过$结束信息第四步：配置接口状态第五步：查看交换机的系统和配置信息第六步：保存配置Copy running-cofig startup-config 将现有的配置保存到启动配置里Write memory , write 写入配置到nvram内路由器的配置第一步：配置路由器的接口并查看接口配置进入config模式，interface fastEthernet 0/1进入接口配置，ip address 配置好接口上的子网第二步：显示路由表的信息在特权模式下输入 show ip route七、实验数据及结果分析：（删去无用的默认部分，留下配置部分）交换机 running-configSW-1#show running-configBuilding configuration...Current configuration : 1143 bytes!version!hostname SW-1!spanning-tree mode pvst!interface FastEthernet0/1description "this is a accessable port!!!"duplex halfspeed 10!interface Vlan1no ip addressshutdown!banner motd ^CWelcome to SW-1!!!!!!!^C!line con 0!line vty 0 4loginline vty 5 15login!!end路由器 running-configRouter#show running-config Building configuration...Current configuration : 419 bytes !version!hostname Router!ip cefno ipv6 cef!interface FastEthernet0/0ip address duplex autospeed auto!ip classless!ip flow-export version 9 !line con 0!line aux 0 !line vty 0 4 login!end八、实验结论、心得体会和改进建议：第一次操作真正的路由器，与之前在家用路由器上玩openwrt，dd-wrt，padavan之类的系统完全不一样。
计算机网络实验报告
实验二网络路由层协议模拟实验报告（1）实验目的和要求1.掌握VB、VC++、VS或JA V A等集成开发环境编写路由仿真程序的方法；2.理解并掌握距离向量路由协议和链路状态路由协议的工作原理。
（2）实验内容2.实现链路状态路由算法的模拟。
基本要求（动态生成网络拓扑图，节点间的距离随机生成。
每个节点生成自己的链路状态分组，依据收到的链路状态表得到整体网络结构，在得到的整体网络结构上用最短路径算法，生成每个节点的路由表）（3）实验原理距离向量路由算法(Bellman-Ford Routing Algorithm)，作为距离向量协议的一个算法，如RIP, （RIP 跳最大跳数16）BGP。
使用这个算法的路由器必须掌握这个距离表，它告诉在网络中每个节点的最远和最近距离。
在距离表中的这个信息是根据临近接点信息的改变而时时更新的。
这个在算法中的度量公式是跳跃的次数，等待时间，流出数据包的数量等等。
概括地说，距离向量算法要求每一个路由器把它的整个路由表发送给与它直接连接的其它路由器。
路由表中的每一条记录都包括目标逻辑地址、相应的网络接口和该条路由的向量距离。
当一个路由器从它的相邻处收到更新信息时，它会将更新信息与本身的路由表相比较。
如果该路由器比较出一条新路由或是找到一条比当前路由更好的路由时，它会对路由表进行更新：将从该路由器到邻居之间的向量距离与更新信息中的向量距离相加作为新路由的向量距离。
在距离向量路由算法中，相邻路由器之间周期性地相互交换各自的路由表备份。
当网络拓扑结构发生变化时，路由器之间也将及时地相互通知有关变更信息。
距离矢量路由算法在理论中可以工作，但在实践中有一个严重的缺陷：虽然它总是能够达到正确的答案，但是它收敛到正确答案的速度非常慢，尤其是，它对于好消息的反应非常快，但是对于坏消息的反应非常迟缓。
（4）编程语言和环境1.编程语言C++；2.编程环境Windows；（5）程序源代码#include <iostream>#include <cstdlib>using namespace std;#define ROUTNUM 7 //定义路由的个数为7个typedef struct{int dis; //存延迟大小int from; //存下一跳的路由}RoutNode;RoutNode data[ROUTNUM][ROUTNUM]; /*路由表，能存7行7列数据,数据为权值*/void InitData(FILE* pfile); /*从数据文件读取数据，初始化路由表*/void OutputRoutData(); /*输出所有的路由表*/void Communication(int recv, int send);/*send点向recv点发送自己的路由表*/void Exchange(); /*所有节点进行一次数据交换, 更新路由表*/int main(){int start, end, i, j;FILE *pfile;pfile = fopen("1.txt", "r");if (pfile == NULL){printf("文件打开错误，按任意键退出.\n");return 0;}elsecout<<"路由表初始"<<endl;InitData(pfile);fclose(pfile);for (i = 0; i<ROUTNUM; i++){printf("%c||", i + 65);for (j = 0; j < ROUTNUM; j++)if (data[i][j].dis > 0)printf("<%c %d> ", j + 65, data[i][j].dis);cout<<endl;} //显示各路由的路由表for (i = 0; i < ROUTNUM; i++) //循环7次（好像多余，改成一次得到同样结果）{Exchange();}printf("\n路由表交换:\n");OutputRoutData();printf("输入起始路由节点数字(%d-%d)[0代表A，1代表B...] : ", 0, ROUTNUM - 1);cin>>start;printf("输入终点路由节点数字(%d-%d)[0代表A，1代表B...] : ", 0, ROUTNUM - 1);cin>>end;if (start == end || start < 0 || start > 6 || end < 0 || end > 6){cout<<"输入错误，请按任意键退出"<<endl;return 0;}else{int cur = start;int total = 0;if (data[start][end].dis < 0){cout<<"没有路由路径发现!"<<endl;return 0;}printf("%c->", cur + 65);while (data[cur][end].from >= 0) //起始点与终点不相连。
距离矢量算法解析
距离矢量详解—包含到其他所有结点开销
存储在结点 的 信 息 A A B C D E F G 0 1 1 ∞ 1 1 ∞ B 1 0 1 ∞ ∞ ∞ ∞ C 1 1 0 1 ∞ ∞ ∞ 到每个结点的距离 D ∞ ∞ 1 0 ∞ ∞ 1 E 1 ∞ ∞ ∞ 0 ∞ ∞ F 1 ∞ ∞ ∞ ∞ 0 1 G ∞ ∞ ∞ 1 ∞ 1 0
存储在每个结点中的初始距离
距离矢量详解—发送包含自己距离表的消息给其他邻接点 1、结点F告诉A它可以到结点G，开销为1，A也知道它能以 开销1到达F，因此二者相加就可以知道经F到G的开销；A 到G的总开销2小于当前的开销无穷大，因此A记录它可经F 到达G，开销为2； 2、类似的，A从C得知，C能以开销1到达D；A将此与到C的 开销1相加，决定可通过C以开销2到达D，优于旧的开销无 穷大 3、同时，A从C得知，C能以开销1到达B，因此它推断经C 到B的开销为2，这比当前A到B的开销1大，因此新的信息 被忽略。
距离矢量详解—发送包含自己距离表的消息给其他邻接点
结点A的初始路由表 目标 B C 开销 1 1 下一跳 B C
结点A的最终路由表 目标 B C D E F G 开销 1 1 2 1 1 2 下一跳 B C C E F C
D
E F G
∞
1 1 ∞
—
E F —
距离矢量详解
存储在结点 的 信 息 A A B C 0 1 1 B 1 0 1 C 1 1 0 到每个结点的距离 D 2 2 1 E 1 2 2 F 1 2 2 G 2 3 2
0
0
10.2.0.0
S0 S1 S1 E1 2
0
0
Possibly Down
10.3.0.0
S0 S0 S0 S0
路由与交换技术实训报告
路由与交换技术实训报告1.引言概述部分的内容可以包括对路由与交换技术的背景和重要性进行介绍。
以下是一个示例：1.1 概述在现代计算机网络中，路由与交换技术是网络通信的基石，它们的作用是实现数据的传输和转发。
随着互联网的普及和应用领域的不断扩大，路由与交换技术的重要性日益凸显。
路由技术是指通过选择合适的路径将数据从源主机传递到目标主机的过程。
随着网络规模不断增大和结构变得复杂，合理的路由选择对于提高网络性能和稳定性至关重要。
路由技术可以实现从小范围内的局域网（LAN）到广域网（WAN）的数据传输，保证信息的安全性和可靠性。
交换技术则是指在网络中进行数据传输和转发的过程。
相比传统的广播方式，交换技术能够更有效地利用网络资源，提高数据传输的速度和可靠性。
常见的交换技术包括以太网交换、虚拟局域网（VLAN）交换和ATM 交换等。
这些交换技术根据数据传输的不同需求和网络规模的不同，为用户提供了多样化的选择。
路由与交换技术的应用广泛，几乎贯穿于各行各业的计算机网络中。
无论是大型企业组织的内部网络，还是互联网的传统ISP（Internet Service Provider）网络，都需要路由与交换技术来实现数据的高效传输。
随着云计算、物联网和5G技术的快速发展，网络规模和复杂性将进一步增加，对路由与交换技术的要求也会更加迫切。
本报告将深入探讨路由与交换技术的相关知识和实践操作，通过实训实验的方式加深对于这些技术的理解和掌握。
我们将重点介绍路由技术的概念、协议以及交换技术的分类，通过实际操作实验，探索如何利用路由与交换技术构建高效的计算机网络，提高网络通信的性能和稳定性。
文章结构部分的内容应该包括对整篇文章的分章节进行介绍和概述。
以下是对文章结构的简要描述：1.2 文章结构部分：本篇报告主要分为以下几个部分，每个部分都涉及不同的内容和技术：1. 引言：在这一部分，我们将对整篇报告进行概述，并介绍本次实训报告的目的。
【协议分析】【距离矢量算法计算过程分析】
实验二十距离矢量算法计算过程分析【实验目的】1. 通过分析距离矢量算法的计算过程，理解距离矢量路由协议的工作原理。
【实验学时】2学时【实验环境】在本实验中需要4台路由、1台交换机、1台RG-PATS网络协议分析仪。
四台路由器运行RIP路由协议，使用协议分析仪采集数据包，对采集到的数据进行分析。
将所有的路由器都接入到交换机上，并在交换机上配置端口映像功能，具体IP分配如下表：表6-2 设备IP地址分配表设备接口IP地址连接到交换机192.168.1.1/24FA0/8 RSR-A FA0/0RSR-A LO0 192.168.10.1/24 --FA0/6 RSR-A FA0/1192.168.3.1/24RSR-B FA0/0 192.168.1.2/24 FA0/9RSR-B FA0/1FA0/10192.168.2.1/24-- RSR-B LO0192.168.20.1/24RSR-C FA0/0 192.168.2.2/24 FA0/7192.168.30.1/24-- RSR-C LO0RSR-D FA0/0 192.168.3.2/24 FA0/6192.168.400.1/24-- RSR-D LO0RG-PATS网络协议分析Eth 0 172.16.1.4 FA0/24仪设备连接如下图所示：249图6-43 实验拓扑图【实验内容】1、使用协议分析仪采集网络中的RIP选路数据包，分析距离矢量算法的计算过程。
【实验流程】图 6-44 实验流程图【实验原理】距离矢量算法是以R.EBellman、L.R.Ford和D.R.Fulkerson所做的工作为基础的，由于这个原因，所以有时距离矢量算法又称为Bellman-Ford或Ford-Fulkerson算法。
250在所有的动态路由协议中，最简单的就是距离矢量路由协议（D-V）。
它使用的是最简单的距离矢量（Distance-Vector，简称D-V）路由算法。
计算机网络实验报告(路由算法、Socket编程)[修改版]
![计算机网络实验报告(路由算法、Socket编程)[修改版]](https://img.taocdn.com/s3/m/7b123c0717fc700abb68a98271fe910ef12dae7f.png)
第一篇：计算机网络实验报告(路由算法、Socket编程)计算机网络实验报告班级：姓名：学号：实验一一．实验目的及要求编写程序，模拟距离矢量路由算法的路由表交换过程，演示交换后的路由表的变化。
二．实验原理距离矢量路由算法是这样工作的：每个路由器维护一张路由表（即一个矢量），它以网络中的每个路由器为索引，表中列出了当前已知的路由器到每个目标路由器的最佳距离，以及所使用的线路。
通过在邻居之间相互交换信息，路由器不断地更新他们的内部路由表。
举例来说，假定使用延迟作为“距离”的度量标准，并且该路由器发送一个列表，其中包含了他到每一个目标路由器的延时估计值；同时，他也从每个邻居路由器接收到一个类似的列表。
假设一个路由器接收到来自邻居x的一个列表，其中x（i）表示x估计的到达路由器i所需要的时间。
如果该路由器知道他到x的延时为m毫秒，那么他也知道在x（i）+m毫秒之间内经过x可以到达路由器i。
一个路由器针对每个邻居都执行这样的计算，就可以发现最佳的估计值，然后在新的路由器表中使用这个最佳的估计值以及对应的输出路线。
三．源程序：#include "stdio.h" #include "stdlib.h" #include "malloc.h" #include "graphics.h" #include "dos.h" #define VERNUM 7typedef struct {int dis;int flag;int flag2; }RoutNode;char tmp[10]; RoutNode data[VERNUM][VERNUM];void welcome();void InitRoutData(FILE* pfile);void PrintRoutData();void SendInf(int recv, int send);void Exchange();int main() {int start, end, i, j, m, n;FILE *pfile;welcome();pfile = fopen("1.txt", "r");if (pfile == NULL){printf("the file wrong,press any key to come back.\n"); getch();return;}elseInitRoutData(pfile);fclose(pfile);printf("\nthe original route table:\n");for (i = 0; i{printf("%c||", i + 65);for (j = 0; j < VERNUM; j++)if (data[i][j].dis > 0)printf("<%c %d> ", j + 65, data[i][j].dis);}PrintRoutData();getch();for (i = 0; i < VERNUM; i++){for (m = 0; m < VERNUM; m++)for (n = 0; n < VERNUM; n++)data[m][n].flag = 0;Exchange();PrintRoutData();getch();}printf("\nexchange the route table:\n"); return 0; }void welcome() {int gdriver=DETECT,gmode; registerbgidriver(EGAVGA_driver); initgraph( &gdriver, &gmode,"C:\Win-TC"); cleardevice();setbkcolor(CYAN);setviewport(0,0,639,479,1); clearviewport();setbkcolor(BLUE);rectangle(200,200,440,280);setfillstyle(1,5);floodfill(300,240,14);settextstyle(0,0,2);outtextxy(50,30,"Distance Vector Routing Algorithm"); setcolor(15);settextstyle(1,0,4);outtextxy(260,214,"Welcome to use!");line(0,80,640,80);getch();delay(300);cleardevice(); } void InitRoutData(FILE* pfile) {char num[10];int i = 0;char c;int m, n;fseek(pfile, 0, 0);for (m = 0; !feof(pfile) && m < 7; m++){for (n = 0; !feof(pfile) && n < 7; n++){while (!feof(pfile)){c = fgetc(pfile);if (c == ','){num[i] = '\0';data[m][n].dis = atoi(num); data[m][n].flag = 0;data[m][n].flag = 0;i = 0;break;} /*end of if*/else if ((c >= '0' && c{num[i++] = c;} /*end of else if*/} /*end of while*/} /*end of for (n = 0*/} /*end of for (m = 0*/ } void PrintRoutData() {int i, j;for (i = 0; i < VERNUM; i++) {settextstyle(1,0,3);sprintf(tmp," %c",i + 65); outtextxy(i*80+50,130,tmp);outtextxy(10,160+i*40,tmp);}for (j = 0; j< VERNUM; j++){for (i = 0; i < VERNUM; i++){if (data[i][j].dis{if(data[i][j].flag2 ==1){setfillstyle(SOLID_FILL,5);bar(80*i+50,40*j+155,80*i+120,40*j+185); delay(50000);data[i][j].flag2 =0;}setfillstyle(SOLID_FILL,3);bar(80*i+50,40*j+155,80*i+120,40*j+185); settextstyle(1,0,2);sprintf(tmp,"-");outtextxy(80*i+65,40*j+165,tmp);}elseif(data[i][j].dis >=0){{setfillstyle(SOLID_FILL,5);bar(80*i+50,40*j+155,80*i+120,40*j+185);delay(50000);data[i][j].flag2 =0;}setfillstyle(SOLID_FILL,3);bar(80*i+50,40*j+155,80*i+120,40*j+185); settextstyle(1,0,2);sprintf(tmp,"%d",data[i][j].dis);outtextxy(80*i+65,40*j+165,tmp);}} /*end of for (j = 0*/} /*end of for (i = 0*/ }void SendInf(int recv, int send) {int i;for (i = 0; i < VERNUM; i++){if (data[send][i].dis > 0&& data[send][i].flag!=1){if (data[recv][i].dis{data[recv][i].dis = data[send][i].dis + data[recv][send].dis;data[recv][i].flag2 =1;}else if (data[recv][i].dis > data[send][i].dis + data[recv][send].dis) {data[recv][i].dis = data[send][i].dis + data[recv][send].dis;data[recv][i].flag =1;data[recv][i].flag2 =1;}} /*end of if*/} /*end of for*/ }void Exchange() {int i, j;for (i = 0; i < VERNUM; i++){for (j = 0; j < VERNUM; j++){if (data[i][j].dis > 0&& data[i][j].flag!=1){SendInf(i, j);} /*end of if*/} /*end of for (j = 0*/} /*end of for (i = 0*/ }四、实验心得体会通过本次实验训练，我了解了距离矢量路由算法的基本原理，复习了C语言编程的内容，通过对路由算法的实现，加深了对路由表交换的理解。
距离矢量路由协议
距离矢量路由协议距离矢量路由协议（Distance Vector Routing Protocol）是计算机网络中常用的一种路由选择协议。
它通过每个路由器根据自身到目的地的距离和方向来选择最佳的路由，从而实现数据包的传输。
在本文中，我们将对距离矢量路由协议进行详细的介绍和分析。
距离矢量路由协议的特点之一是它基于每个节点之间交换信息的方式。
每个节点会周期性地向相邻节点发送路由表信息，以便更新整个网络的路由信息。
这种方式虽然简单，但是也带来了一些问题，比如收敛速度慢、易产生环路等。
为了解决这些问题，距离矢量路由协议引入了一些机制，比如拆分-跳数（Split-Horizon）和毒性逆转（Poison Reverse）。
拆分-跳数机制规定了当一个节点接收到的路由信息中包含了自己发送的信息时，应该将该路由信息丢弃，从而避免产生环路。
而毒性逆转机制则是在路由信息中用无穷大的距离表示不可达的路由，以通知其他节点该路由不可用。
除此之外，距离矢量路由协议还存在着一些其他问题，比如计时器问题、计数到无穷等。
计时器问题是指当节点长时间没有收到邻居节点的路由信息时，应该如何处理。
而计数到无穷则是指当一个节点认为某个路由不可达时，它应该如何通知其他节点。
总的来说，距离矢量路由协议虽然存在一些问题，但是它在一些小型网络中仍然具有一定的优势。
它的实现简单，对网络资源的消耗相对较小，适用于一些对网络要求不是很高的场景。
然而，在大型网络中，距离矢量路由协议的缺点就会显现出来，比如收敛速度慢、容易产生环路等。
在实际应用中，我们需要根据网络的规模和要求来选择合适的路由协议。
对于小型网络，距离矢量路由协议可能是一个不错的选择；而对于大型网络，我们可能需要考虑其他更为复杂的路由协议，比如链路状态路由协议（Link State Routing Protocol）等。
总之，距离矢量路由协议作为计算机网络中常用的一种路由选择协议，它具有一定的优势和局限性。
实验三距离矢量路由算法原理实验报告
电子科技大学通信学院《计算机通信网实验报告》距离矢量路由算法原理实验班级通信11班学生李楚鸣学号 20教师徐世中实验2：距离矢量路由算法原理实验报告【实验目的】1、要求实验者利用路由选择算法模拟软件提供的通信功能，模拟距离矢量路由选择算法的初始化、路由信息扩散过程和路由计算方法；2、掌握距离矢量算法的路由信息扩散过程；3、掌握距离矢量算法的路由计算方法。
【实验环境】1、分组实验，每组4~10人。
2、拓扑：虚线表示节点之间的逻辑关系，构成一个逻辑上的网状拓扑结构。
3、设备：小组中每人一台计算机。
4、实验软件：路由选择算法模拟软件（routing.exe——最新版本为5.0）【实验原理】（请根据实验指导书的相关内容及课程相关知识填写，距离矢量路由算法基本原理，实验软件的基本功能等）【实验步骤】1、建立实验小组。
2、按照距离矢量算法完成路由信息扩散和路由计算过程。
3、距离矢量算法收敛后，向路由表中列出的每个非直连节点发送路由测试数据，完成路由测试过程。
4、汇总实验小组的实验记录信息，检查路由是否正确。
如果有错误，分析并发现错误产生的原因。
5、将实验从头多做几次，观察如果各节点发送信息和接收处理信息的过程不一样，是否会影响路由表的正确形成。
如在第一次实验时，节点接收一份路由信息后，处理，再发送出新的路由信息，而第二次实验时，节点将当前所有的路由信息处理完后，才发送新的路由信息。
6、小组讨论将拓扑中的一条链路断掉，然后通过实验观察路由协议是如何适应这个变化的。
*7、小组讨论无穷计数问题如何在现有拓扑中产生，然后通过实验将无穷计数问题展现出来。
（选作）【实验记录】按照实验记录内容格式要求记录以下内容（不够请另附纸张）：1、实验小组的建立要求记录：小组名称、成员数量、本节点编号、本地直连链路表和据此形成的路由表。
2、距离矢量算法的路由扩散和路由计算过程要求记录：每次发送、接收的路由信息和根据接收信息所形成的路由表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机网络实验报告距离矢量路由算法一，实验内容：A D设计一个算法，实现上面拓扑图的各个结点之间路由表的交换，要求显示出结点路由表的交换过程并显示每次交换结束后的各个结点保存的路由表的内容。
最后显示交换了几次后各个结点路由表开始变得稳定。
二，算法设计：首先创建一个类。
它有两个成员变量。
一个是二维数组型的x[i][j]用来存放从加点i到结点j的距离，一个是一位数组型的y[i]用来存放从源结点到目标结点i的路径上的第一个途经的结点。
然后为每一个结点实例化一个对象用来存放此节点的路由表。
初始化各个节点的路由表，如果两个节点之间有连线则将其之间的距离赋给x[i][j],y[j]=j.如果没有直接路径则设x[i][j]=1000,y[j]=0.算法开始的时候各个结点交换路由表。
比较如果有类似x[i][j]和x[j][k]的项则设置x[i][k]=MIN(x[i][k],x[i][j]+x[j][k]),为了在结点A的邻居节点执行距离矢量路由更新时，它使用的是A的旧表，可以再设置两个二维数组用来暂时存放各个节点的新路由表，待各个节点一次交换都完毕后在把暂存的新节点依次赋给各个节点的路由表。
各个节点都执行此操作，为了确定供交换了几次可以设置一个标质量k.初始k=0，交换一次K就加一，最后k的值便是交换的次数。
三，遇到的问题及解决方案：刚开始遇到这个题目是觉得无从下手，觉得这个图这么复杂函数循环又没有规律怎样让各个节点依次交换呢，又怎样判断什么时候各个节点的路由表变稳定呢？着一些列的问题使自己变得很烦躁。
待到心情平静下来认真的一点一点推敲的时候发现只有七个节点，为每个节点设置一个交换函数也不麻烦而且这样思路便变得非常的清楚，至于怎样知道何时路由表稳定则我在每个结点函数中设置了一个标志量，在主函数中将其初始化为零，在下面的结点函数中都将其变成1，这样只有调用子函数这个标志量便会变成1，检测标质量是否为1来判断路由表是否变的稳定。
四，源代码package wangluo;class Jiedian {int y[]=new int[8]; //存放路径上的下一个节点int x[][]=new int[8][8]; //存放节点间的距离}public class Luyou {public static void main(String[] args) {Jiedian a=new Jiedian();a.x[0][0]=0; //结点0到结点0的距离为0a.y[0]=0; //a结点（即0结点）到0结点路径上第一个结点为0 a.x[0][1]=2;a.y[1]=1;a.x[0][2]=1000; //如果没有直接路径则定义为1000便是无穷远a.x[0][3]=1000;a.x[0][4]=1000;a.x[0][5]=1000;a.x[0][6]=6;a.y[6]=6;a.x[0][7]=1000;Jiedian b=new Jiedian();b.x[1][0]=2;b.y[0]=0;b.x[1][1]=0;b.y[1]=1;b.x[1][2]=7;b.y[2]=2;b.x[1][3]=1000;b.x[1][4]=2;b.y[4]=4;b.x[1][5]=1000;b.x[1][6]=1000;b.x[1][7]=1000;Jiedian c=new Jiedian();c.x[2][0]=1000;c.x[2][1]=7;c.y[1]=1;c.x[2][2]=0;c.y[2]=2;c.x[2][3]=3;c.y[3]=3;c.x[2][4]=1000;c.x[2][5]=3;c.y[5]=5;c.x[2][6]=1000;c.x[2][7]=1000;Jiedian d=new Jiedian();d.x[3][0]=1000;d.x[3][1]=1000;d.y[2]=2;d.x[3][3]=0;d.y[3]=3;d.x[3][4]=1000;d.x[3][5]=1000;d.x[3][6]=1000;d.x[3][7]=2;d.y[7]=7;Jiedian e=new Jiedian();e.x[4][0]=1000;e.x[4][1]=2;e.y[1]=1;e.x[4][2]=1000;e.x[4][3]=1000;e.x[4][4]=0;e.y[4]=4;e.x[4][5]=2;e.y[5]=5;e.x[4][6]=1;e.y[6]=6;e.x[4][7]=1000;Jiedian f=new Jiedian();f.x[5][0]=1000;f.x[5][1]=1000;f.x[5][2]=3;f.y[2]=2;f.x[5][3]=1000;f.x[5][4]=2;f.y[4]=4;f.x[5][5]=0;f.y[5]=5;f.x[5][6]=1000;f.x[5][7]=2;f.y[7]=7;Jiedian g=new Jiedian();g.x[6][0]=6;g.y[0]=0;g.x[6][1]=1000;g.x[6][2]=1000;g.x[6][3]=1000;g.y[4]=4;g.x[6][5]=1000;g.x[6][6]=0;g.y[6]=6;g.x[6][7]=4;g.y[7]=7;Jiedian h=new Jiedian();h.x[7][0]=1000;h.x[7][1]=1000;h.x[7][2]=1000;h.x[7][3]=2;h.y[3]=3;h.x[7][4]=1000;h.x[7][5]=2;h.y[5]=5;h.x[7][6]=4;h.y[6]=6;h.x[7][7]=0;h.y[7]=7;int m[][]=new int[8][8]; //暂时存放各节点新表int n[][]=new int[8][8]; //暂时存放各结点到其他节点的路径上的第一个途经结点int k=0;do{k=0;//for(int j=0;j<6;j++){for(int i=0;i<8;i++){m[0][i]=a.x[0][i];m[1][i]=b.x[1][i];m[2][i]=c.x[2][i];m[3][i]=d.x[3][i];m[4][i]=e.x[4][i];m[5][i]=f.x[5][i];m[6][i]=g.x[6][i];m[7][i]=h.x[7][i];n[0][i]=a.y[i];n[1][i]=b.y[i];n[2][i]=c.y[i];n[3][i]=d.y[i];n[4][i]=e.y[i];n[5][i]=f.y[i];n[6][i]=g.y[i];n[7][i]=h.y[i];}for(int i=0;i<8;i++) //将a的邻居结点的表传给aif(m[0][i]>(a.x[0][1]+b.x[1][i])){ //结点bm[0][i]=a.x[0][1]+b.x[1][i];n[0][i]=1;k=1; //标记。
如果标有变动则k=1 }for(int i=0;i<8;i++)if(m[0][i]>(a.x[0][6]+g.x[6][i])){ //结点gm[0][i]=a.x[0][6]+g.x[6][i];n[0][i]=6;k=1;}for(int i=0;i<8;i++) //将b结点的邻居节点的表传给b if(m[1][i]>(b.x[1][2]+c.x[2][i])){ //结点cm[1][i]=b.x[1][2]+c.x[2][i];n[1][i]=2;k=1;}for(int i=0;i<8;i++)if(m[1][i]>(b.x[1][0]+a.x[0][i])){ //结点am[1][i]=b.x[1][0]+a.x[0][i];n[1][i]=0;k=1;}for(int i=0;i<8;i++)if(m[1][i]>(b.x[1][4]+e.x[4][i])){ //结点em[1][i]=b.x[1][4]+e.x[4][i];n[1][i]=4;k=1;}for(int i=0;i<8;i++) //将c的邻居结点的表传给c if(m[2][i]>(c.x[2][1]+b.x[1][i])){ //结点bm[2][i]=c.x[2][1]+b.x[1][i];n[2][i]=1;k=1;}for(int i=0;i<8;i++)if(m[2][i]>(c.x[2][3]+d.x[3][i])){ //结点dm[2][i]=c.x[2][3]+d.x[3][i];n[2][i]=3;k=1;}for(int i=0;i<8;i++)if(m[2][i]>(c.x[2][5]+f.x[5][i])){ //结点fm[2][i]=c.x[2][5]+f.x[5][i];n[2][i]=5;k=1;}for(int i=0;i<8;i++) //将d的邻居结点的表传给dif(m[3][i]>(d.x[3][2]+c.x[2][i])){ //结点cm[3][i]=d.x[3][2]+c.x[2][i];n[3][i]=2;k=1;}for(int i=0;i<8;i++)if(m[3][i]>(d.x[3][7]+h.x[7][i])){ //结点hm[3][i]=d.x[3][7]+h.x[7][i];n[3][i]=7;k=1;}for(int i=0;i<8;i++) //将e的邻居结点的表传给eif(m[4][i]>(e.x[4][1]+b.x[1][i])){ //结点bm[4][i]=e.x[4][1]+b.x[1][i];n[4][i]=1;k=1;}for(int i=0;i<8;i++)if(m[4][i]>(e.x[4][5]+f.x[5][i])){ //结点fm[4][i]=e.x[4][5]+f.x[5][i];n[4][i]=5;k=1;}for(int i=0;i<8;i++)if(m[4][i]>(e.x[4][6]+g.x[6][i])){ //结点gm[4][i]=e.x[4][6]+g.x[6][i];n[4][i]=6;k=1;}for(int i=0;i<8;i++) //将f的邻居结点的表传给fif(m[5][i]>(f.x[5][2]+c.x[2][i])){ //结点cm[5][i]=f.x[5][2]+c.x[2][i];n[5][i]=2;k=1;}for(int i=0;i<8;i++)if(m[5][i]>(f.x[5][4]+e.x[4][i])){ //结点em[5][i]=f.x[5][4]+e.x[4][i];n[5][i]=4;k=1;}for(int i=0;i<8;i++)if(m[5][i]>(f.x[5][7]+h.x[7][i])){ //结点fm[5][i]=f.x[5][7]+h.x[7][i];n[5][i]=7;k=1;}for(int i=0;i<8;i++) //将g的邻居结点的表传给gif(m[6][i]>(g.x[6][0]+a.x[0][i])){ //结点am[6][i]=g.x[6][0]+a.x[0][i];n[6][i]=0;k=1;}for(int i=0;i<8;i++)if(m[6][i]>(g.x[6][4]+e.x[4][i])){ //结点em[6][i]=g.x[6][4]+e.x[4][i];n[6][i]=4;k=1;}for(int i=0;i<8;i++)if(m[6][i]>(g.x[6][7]+h.x[7][i])){ //结点hm[6][i]=g.x[6][7]+h.x[7][i];n[6][i]=7;k=1;}for(int i=0;i<8;i++) //将g的邻居结点的表传给gif(m[7][i]>(h.x[7][3]+d.x[3][i])){ //结点dm[7][i]=h.x[7][3]+d.x[3][i];n[7][i]=3;k=1;}for(int i=0;i<8;i++)if(m[7][i]>(h.x[7][5]+f.x[5][i])){ //结点dm[7][i]=h.x[7][5]+f.x[5][i];n[7][i]=5;k=1;}for(int i=0;i<8;i++)if(m[7][i]>(h.x[7][6]+g.x[6][i])){ //结点dm[7][i]=h.x[7][6]+g.x[6][i];n[7][i]=6;k=1;}for(int i=0;i<8;i++){a.x[0][i]=m[0][i];b.x[1][i]=m[1][i];c.x[2][i]=m[2][i];d.x[3][i]=m[3][i];e.x[4][i]=m[4][i];f.x[5][i]=m[5][i];g.x[6][i]=m[6][i];h.x[7][i]=m[7][i];a.y[i]=n[0][i];b.y[i]=n[1][i];c.y[i]=n[2][i];d.y[i]=n[3][i];e.y[i]=n[4][i];f.y[i]=n[5][i];g.y[i]=n[6][i];h.y[i]=n[7][i];}System.out.println("a的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+a.x[0][i]); System.out.println("途经"+a.y[i]);}System.out.println("b的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+b.x[1][i]);System.out.println("途经"+b.y[i]);}System.out.println("c的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+c.x[2][i]);System.out.println("途经"+c.y[i]);}System.out.println("d的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+d.x[3][i]);System.out.println("途经"+d.y[i]);}System.out.println("e的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+e.x[4][i]);System.out.println("途经"+e.y[i]);}System.out.println("f的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+f.x[5][i]);System.out.println("途经"+f.y[i]);}System.out.println("g的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+g.x[6][i]);System.out.println("途经"+g.y[i]);}System.out.println("h的路由表为：");for(int i=0;i<8;i++){System.out.println("到"+i+"结点的距离： "+h.x[7][i]);System.out.println("途经"+h.y[i]);}System.out.println("一遍结束！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！");}while(k==1);// }}}五，测试结果：一，实验感悟：通过本次的距离矢量路由算法是我更深刻的理解了这一算法的运行过程以及细节，也是自己对于网络上的算法编程有了初步的认识与了解，关键是要静下心来自习的想，越是急躁越是容易把问题复杂化而没有思路。