logo资料库

网络路由层协议模拟实验报告.doc

第1页 / 共6页
第2页 / 共6页
第3页 / 共6页
第4页 / 共6页
第5页 / 共6页
第6页 / 共6页
资料共6页,全文预览结束
一. 实验目的
二. 实验内容
三.实验原理
四. 实验步骤
1 编写程序
2.设计思路
五.实验结果分析
1 结果截图
2结果分析
实验一:网络路由层协议模拟实验 一. 实验目的 模拟链路状态路由算法的路由表交换过程,演示每轮交换后路由表的变化。 二. 实验内容 要求编程实现距离矢量路由算法的路由表交换过程,并动态演示每轮交换过 后路由表的变化情况。 三.实验原理 链路状态路由协议是目前使用最广的一类域内路由协议。它采用一种“拼图” 的设计策略,即每个路由器将它到其周围邻居的链路状态向全网的其他路由器进 行广播。这样,一个路由器收到从网络中其他路由器发送过来的路由信息后,它 对这些链路状态进行拼装,最终生成一个全网的拓扑视图,近而可以通过最短路 径算法来计算它到别的路由器的最短路径。 链路状态路由算法背后的思想非常简单,可以用 5 个部分加以描述。每一个 路由器必须完成以下的工作: (1)发现它的邻居节点,并知道其网络地址。 (2)测量到各邻居节点的延迟或者开销。 (3)构造一个分组,分组中包含所有它刚刚知道的消息。 (4)将这个分组发送给所有其它的路由器。 (5)计算出到每一个其他路由器的最短路径。 每个路由器运行 Dijkstra 算法就可以找从它到每一个其他路由器的最短路径。 四. 实验步骤 1 编写程序 程序源代码如下: #include
//N 节点数 #include const int N = 6, Infinite = 1000; class edge { public: int numver; int weight; edge* nextedge; edge(int num, int w, edge *next) { numver = num; weight = w; nextedge = next; } }; class vertex { public: int distance[N]; char by[N]; edge* firstedge; vertex(edge *next) { } firstedge = next; }; int main(int argc, char* argv[]) { vertex *v[N]; int m, w; edge *e, *e1; char c; void BuildGraph(vertex *v[]); void ShortestPaths(vertex *v[], int v0); void print(vertex *v[]); BuildGraph(v); for (int i = 0; i < N; i++) print(v); do { ShortestPaths(v, i); cout<<"Input a node: "; //输入节点若已启动,则将其停止,否则,反之 cin>>c; m = c - 65; e = v[m]->firstedge; if (e->weight < Infinite) //将输入的节点字符转换为编号 //检查输入节点的邻边 //若邻边的权小于无穷大,则将此节点断开 do { e->weight += Infinite; w = e->numver; e1 = v[w]->firstedge; while (e1->numver != m) e1 = e1->nextedge; //将此节点到邻居节点的权设为无穷大
e1->weight += Infinite; //将其它节点到输入节点的权设为无穷大 e = e->nextedge; } while (e != NULL); else do { //检查输入节点的所有邻边 //否则,将此节点连通 //恢复为原来的权值 //求出从 v0 出发到其它各个节点的 父节点 edge *e; int s[N], u, dist, father[N], num; //father[i]记录最短路径上节点 i 的 for (int i = 0; i < N; i++) { e->weight -= Infinite; w = e->numver; e1 = v[w]->firstedge; while( e1->numver != m ) e1 = e1->nextedge; e1->weight -= Infinite; e = e->nextedge; } while (e != NULL); for (int i = 0; i < N; i++) print(v); ShortestPaths(v, i); } while(c != '0'); return 0; } int Mindist(int dist[], int s[]) { int min = Infinite * 2; int node; for (int i = 0; i < N; i++) if (s[i] == 0 && dist[i] < min) { min = dist[i]; node = i; } return node; } void ShortestPaths(vertex *v[], int v0) 最短距离 { s[i] = 0; father[i] = v0; v[v0]->distance[i] = Infinite; v[v0]->by[i] = i + 65; } e = v[v0]->firstedge; while (e != NULL) { } s[v0] = 1; v[v0]->distance[v0] = 0; for (i = 1; i < N; i++) { v[v0]->distance[e->numver] = e->weight; e = e->nextedge;
dist = v[v0]->distance[u] + e->weight; break; } e = e->nextedge; } if (dist < v[v0]->distance[j])//更新所有节点到 v0 的最短距离 { father[j] = u; v[v0]->distance[j] = dist; } } } } for (i = 0; i < N; i++) //计算从 v0 出发到各个节点最短距离经过的邻近节点 { u = Mindist(v[v0]->distance, s); //选出最短路径经过的节点(此节点还未 被计入 S //将此节点计入 S s[u] = 1; for (int j = 0; j < N; j++) { if (s[j] == 0) { dist = Infinite; e = v[u]->firstedge; while (e != NULL) { if (e->numver == j) { num = i; while (father[num]! = v0) v[v0]->by[i] = num + 65; num = father[num]; } } void BuildGraph(vertex *v[]) { edge *e, *e1, *e2; e1 = new edge(4, 5, NULL); e = new edge(1, 4, e1); v[0] = new vertex(e); e2 = new edge(5, 6, NULL); e1 = new edge(2, 2, e2); e = new edge(0, 4, e1); v[1] = new vertex(e); e2 = new edge(4, 1, NULL); e1 = new edge(3, 3, e2); e = new edge(1, 2, e1); v[2] = new vertex(e); e1 = new edge(5, 7, NULL); e = new edge(2, 3, e1); v[3] = new vertex(e); e2 = new edge(5, 8, NULL); e1 = new edge(2, 1, e2); e = new edge(0, 5, e1); v[4] = new vertex(e); e2 = new edge(4, 8, NULL);
e1 = new edge(3, 7, e2); e = new edge(1, 6, e1); v[5] = new vertex(e); } void print(vertex *v[]) { D F"<distance[j] >= Infinite || v[i]->distance[j] == 0) else cout<<"-"<<"\t"; cout<distance[j]<<" "<by[j]<<"\t"; } cout<
2 结果分析 该程序是简化了链路状态路由算法,在建立图的过程中已经完成了链路状态 路由算法的前四步,最后只对选中的节点运行 Dijkstra 算法,即链路状态路由算 法的最后一步。因此,该程序与实际使用的链路状态路由算法相差较大。
分享到:
收藏