实验一:网络路由层协议模拟实验
一. 实验目的
模拟链路状态路由算法的路由表交换过程,演示每轮交换后路由表的变化。
二. 实验内容
要求编程实现距离矢量路由算法的路由表交换过程,并动态演示每轮交换过
后路由表的变化情况。
三.实验原理
链路状态路由协议是目前使用最广的一类域内路由协议。它采用一种“拼图”
的设计策略,即每个路由器将它到其周围邻居的链路状态向全网的其他路由器进
行广播。这样,一个路由器收到从网络中其他路由器发送过来的路由信息后,它
对这些链路状态进行拼装,最终生成一个全网的拓扑视图,近而可以通过最短路
径算法来计算它到别的路由器的最短路径。
链路状态路由算法背后的思想非常简单,可以用 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 算法,即链路状态路由算
法的最后一步。因此,该程序与实际使用的链路状态路由算法相差较大。