DV算法1

最新推荐文章于 2023-02-23 20:10:57 发布
最新推荐文章于 2023-02-23 20:10:57 发布
阅读量2k 收藏 1
点赞数
分类专栏： 其它 文章标签： 算法 distance struct table initialization function

作者：冰蓝沸点
        

    DVSim.h:
       #include     <stdio.h>
#include     <stdlib.h>
#include    <process.h>
#include    <io.h>
#include    <iostream.h>

#define        INF        999
#define        NODES        5
#define     LINKCHANGES     0

/*--------------------------------------------------------------
*    distance_table definition:
*
*    costs[i][j]= path cost from this node to node i
*            when first hop is node j
*--------------------------------------------------------------*/
struct     distance_table
    {
        int costs[NODES][NODES];
    };


#ifdef DVSIM_H
/*------------------------------
*    Trace level
*------------------------------*/
int    TRACE = 1;


/*--------------------------------------
*    distance tables
*    minimum path costs
*    link costs
*--------------------------------------*/
struct     distance_table    dt[NODES];
int     min_cost[NODES][NODES];
int     linkcost[NODES][NODES] = {
        {0, 1, 2, INF, INF},
        {1, 0, INF, 15, 5},
        {2, INF, 0, 1, 2},
        {INF, 15, 1, 0, 10},
        {INF, 5, 2, 10, 0}
};
#else
extern int     TRACE;
extern struct    distance_table dt[NODES];
extern int     min_cost[NODES][NODES];
extern int     linkcost[NODES][NODES];

extern int rpc0 = 0;
extern int rpc1 = 0;
extern int rpc2 = 0;
extern int rpc3 = 0;
extern int rpc4 = 0;

extern int spc0 = 0;
extern int spc1 = 0;
extern int spc2 = 0;
extern int spc3 = 0;
extern int spc4 = 0;

#endif


/*--------------------------------------------------------------
*       rtpkt       Routing packet
*
*    sourceid    source router
*    destid       dest router (must be immediate neighbor)
*    mincost[]    minimum cost to other nodes
*--------------------------------------------------------------*/
struct rtpkt {
        int sourceid;
        int destid;
        int mincost[NODES];
};

/*------------------------------
*    function prototypes
*------------------------------*/
void     rtinit0();
void     rtinit1();
void     rtinit2();
void     rtinit3();
void     rtinit4();


void     rtupdate0 (struct rtpkt *);
void     rtupdate1 (struct rtpkt *);
void     rtupdate2 (struct rtpkt *);
void     rtupdate3 (struct rtpkt *);
void     rtupdate4 (struct rtpkt *);


void     printdt_0 (struct distance_table *);
void     printdt_1 (struct distance_table *);
void     printdt_2 (struct distance_table *);
void     printdt_3 (struct distance_table *);
void     printdt_4 (struct distance_table *);


void    linkhandler0 (int, int);
void     linkhandler1 (int, int);

double    get_clock();
void    tolayer2 (struct rtpkt);



/*    END DVsim.h ------------------------------------------*/



        Node.cpp
/*************************************************************************
*   node0.c    
*
*   Distance Vector Routing Simulation Package
*   Node event handlers
*
*   INITIALIZATION FUNCTION:    rtinit0
*   
*    1. initializes distance table for node 0
*    2. computes initial minimum path costs for node 0
*    3. send update packets to neighbors
*
*
*   UPDATE FUNCTION:         rtupdate0
*
*    Executes when the node receives an updates message:
*    1. receives update from neighbor
*    2. computes new values for distance table
*    3. if any minimum path cost changes, then sends update messages
*       to all neighbors.
*
*
*   TABLE PRINT FUNCTIONS:     printdt_0
*
*    Prints distance table for node 0.
*
*
*   LINK HANDLER FUNCTIONS:    linkhandler_0, linkhandler_1
*
*     These functions are called when the link cost from node 0 to
*    node "linkid" changes from the current value to newcost.
*    To use these, change constant LINKCHANGE in DVsim.c from 0 to 1.
*     Leave these functions empty for the standard project.
*
*-----------------------------------------------------------------------*/
#include     "DVsim.h"

/*------------------------
*    rtinit0
*------------------------*/
void rtinit0()
{
    for(int i = 0; i < NODES; i++)
        for(int j = 0; j < NODES; j++)
            dt[0].costs[i][j] = INF;       //The first step of initializing node0's costs table.
   
    for(i = 0; i < NODES; i++)             //The first step of initializing node0's min_cost table
        min_cost[0][i] = INF;              //The reason of seperating the initiazing process is
                                           //just for easy-coding.

    dt[0].costs[0][0] = min_cost[0][0] = 0;//The second step of initializing node0's min_cost table and
                                           //costs table. Their relationship can be drawn from the analyzing graph
    dt[0].costs[1][1] = min_cost[0][1] = 1;
    dt[0].costs[2][2] = min_cost[0][2] = 2;

    rtpkt pki;
    pki.sourceid = 0;
    for(i = 0; i < NODES; i++)
        pki.mincost[i] = dt[0].costs[i][i];//initializing the data segment in the packet.
    pki.destid = 1;
    tolayer2(pki);
    pki.destid = 2;
    tolayer2(pki);   
    spc0 += 2;
}

/*------------------------
*    rtinit1
*------------------------*/
void rtinit1()
{
    int i;
    for(i = 0; i < NODES; i++)
        for(int j = 0; j < NODES; j++)
            dt[1].costs[i][j] = INF;

    for(i = 0; i < NODES; i++)
        min_cost[1][i] = INF;

    dt[1].costs[0][0] = min_cost[1][0] = 1;
    dt[1].costs[1][1] = min_cost[1][1] = 0;
    dt[1].costs[3][3] = min_cost[1][3] = 15;
    dt[1].costs[4][4] = min_cost[1][4] = 5;

    rtpkt pki;
    pki.sourceid = 1;
    for(i = 0; i < NODES; i++)
        pki.mincost[i] = dt[1].costs[i][i];
    pki.destid = 0;
    tolayer2(pki);
    pki.destid = 3;
    tolayer2(pki);
    pki.destid = 4;
    tolayer2(pki);
    spc1 += 3;
}

/*------------------------
*    rtinit2
*------------------------*/
void rtinit2()
{
    int i;
    for(i = 0; i < NODES; i++)
        for(int j = 0; j < NODES; j++)
            dt[2].costs[i][j] = INF;

    for(i = 0; i < NODES; i++)
        min_cost[2][i] = INF;

    dt[2].costs[0][0] = min_cost[2][0] = 2;
    dt[2].costs[2][2] = min_cost[2][2] = 0;
    dt[2].costs[3][3] = min_cost[2][3] = 1;
    dt[2].costs[4][4] = min_cost[2][4] = 2;

    rtpkt pki;
    pki.sourceid = 2;
    for(i = 0; i < NODES; i++)
        pki.mincost[i] = dt[2].costs[i][i];
    pki.destid = 0;
    tolayer2(pki);
    pki.destid = 3;
    tolayer2(pki);
    pki.destid = 4;
    tolayer2(pki);
    spc2 += 3;
}

/*------------------------
*    rtinit3
*------------------------*/
void rtinit3()
{
    int i;
    for(i = 0; i < NODES; i++)
        for(int j = 0; j < NODES; j++)
            dt[3].costs[i][j] = INF;

    for(i = 0; i < NODES; i++)
        min_cost[3][i] = INF;

    dt[3].costs[1][1] = min_cost[3][1] = 15;
    dt[3].costs[2][2] = min_cost[3][2] = 1;
    dt[3].costs[3][3] = min_cost[3][3] = 0;
    dt[3].costs[4][4] = min_cost[3][4] = 10;

    rtpkt pki;
    pki.sourceid = 3;
    for(i = 0; i < NODES; i++)
        pki.mincost[i] = dt[3].costs[i][i];
    pki.destid = 1;
    tolayer2(pki);
    pki.destid = 2;
    tolayer2(pki);
    pki.destid = 4;
    tolayer2(pki);
    spc3 += 3;
}

/*------------------------
*    rtinit4
*------------------------*/
void rtinit4()
{
    int i;
    for(i = 0; i < NODES; i++)
        for(int j = 0; j < NODES; j++)
            dt[4].costs[i][j] = INF;

    for(i = 0; i < NODES; i++)
        min_cost[4][i] = INF;

    dt[4].costs[1][1] = min_cost[4][1] = 5;
    dt[4].costs[2][2] = min_cost[4][2] = 2;
    dt[4].costs[3][3] = min_cost[4][3] = 10;
    dt[4].costs[4][4] = min_cost[4][4] = 0;

    rtpkt pki;
    pki.sourceid = 4;
    for(i = 0; i < NODES; i++)
        pki.mincost[i] = dt[4].costs[i][i];
    pki.destid = 1;
    tolayer2(pki);
    pki.destid = 2;
    tolayer2(pki);
    pki.destid = 3;
    tolayer2(pki);
    spc4 += 3;
}

/*------------------------
*    rtupdate0
*------------------------*/
void rtupdate0 (struct rtpkt *rcvdpkt)
{
    int i, newWeight;
    bool changed = false;       //check if the mincost has changed.
    rtpkt pku;
    pku.sourceid = 0;
    for(i = 0; i < NODES; i++)
        pku.mincost[i] = min_cost[0][i];    //initializing

    rpc0++;

    for(i = 0; i < NODES; i++)//kernel part of the DVAlgorithm
    {
        newWeight = dt[0].costs[rcvdpkt->sourceid][rcvdpkt->sourceid] + rcvdpkt->mincost[i];//receive a packet, update according to the incoming info.
        if(newWeight < dt[0].costs[i][rcvdpkt->sourceid] && i != 0)
        {
            dt[0].costs[i][rcvdpkt->sourceid] = newWeight;//check if the private costs table should be updated.
            if(newWeight < min_cost[0][i])//check if the public min_cost table should be updated
            {
                pku.mincost[i] = min_cost[0][i] = newWeight;
                changed = true;
            }
        }
    }

    if(changed){
        pku.destid = 1;
        tolayer2(pku);
        pku.destid = 2;
        tolayer2(pku);
        spc0 += 2;
    }
}

/*------------------------
*    rtupdate1
*------------------------*/
void rtupdate1(struct rtpkt *rcvdpkt)
{
    int i, newWeight;
    bool changed = false;
    rtpkt pku;
    pku.sourceid = 1;
    for(i = 0; i < NODES; i++)
        pku.mincost[i] = min_cost[1][i];

    rpc1++;

    for(i = 0; i < NODES; i++)
    {
        newWeight = dt[1].costs[rcvdpkt->sourceid][rcvdpkt->sourceid] + rcvdpkt->mincost[i];
        if(newWeight<dt[1].costs[i][rcvdpkt->sourceid] && i!=1)
        {
            dt[1].costs[i][rcvdpkt->sourceid] = newWeight;
            if(newWeight < min_cost[1][i])
            {
                pku.mincost[i] = min_cost[1][i] = newWeight;
                changed = true;
            }
        }
    }

    if(changed){
        pku.destid = 0;
        tolayer2(pku);
        pku.destid = 3;
        tolayer2(pku);
        pku.destid = 4;
        tolayer2(pku);
        spc1 += 3;
    }
}

/*------------------------
*    rtupdate2
*------------------------*/
void rtupdate2(struct rtpkt *rcvdpkt)
{
    int i, newWeight;
    bool changed = false;
    rtpkt pku;
    pku.sourceid = 2;
    for(i = 0; i < NODES; i++)
        pku.mincost[i] = min_cost[2][i];

    rpc2++;

    for(i = 0; i < NODES; i++)
    {
        newWeight = dt[2].costs[rcvdpkt->sourceid][rcvdpkt->sourceid] + rcvdpkt->mincost[i];
        if(newWeight<dt[2].costs[i][rcvdpkt->sourceid] && i!=2)
        {
            dt[2].costs[i][rcvdpkt->sourceid] = newWeight;
            if(newWeight < min_cost[2][i])
            {
                pku.mincost[i] = min_cost[2][i] = newWeight;
                changed = true;
            }
        }
    }

    if(changed){
        pku.destid = 0;
        tolayer2(pku);
        pku.destid = 3;
        tolayer2(pku);
        pku.destid = 4;
        tolayer2(pku);
        spc2 += 3;
    }
}

/*------------------------
*    rtupdate3
*------------------------*/
void rtupdate3(struct rtpkt *rcvdpkt)
{
    int i, newWeight;
    bool changed = false;
    rtpkt pku;
    pku.sourceid = 3;
    for(i = 0; i < NODES; i++)
        pku.mincost[i] = min_cost[3][i];

    rpc3++;

    for(i = 0; i < NODES; i++)
    {
        newWeight = dt[3].costs[rcvdpkt->sourceid][rcvdpkt->sourceid] + rcvdpkt->mincost[i];
        if(newWeight<dt[3].costs[i][rcvdpkt->sourceid] && i!=3)
        {
            dt[3].costs[i][rcvdpkt->sourceid] = newWeight;
            if(newWeight < min_cost[3][i])
            {
                pku.mincost[i] = min_cost[3][i] = newWeight;
                changed = true;
            }
        }
    }

    if(changed){
        pku.destid = 1;
        tolayer2(pku);
        pku.destid = 2;
        tolayer2(pku);
        pku.destid = 4;
        tolayer2(pku);
        spc3 += 3;
    }
}

/*------------------------
*    rtupdate1
*------------------------*/
void rtupdate4(struct rtpkt *rcvdpkt)
{
    int i, newWeight;
    bool changed = false;
    rtpkt pku;
    pku.sourceid = 4;
    for(i = 0; i < NODES; i++)
        pku.mincost[i] = min_cost[4][i];

    rpc4++;

    for(i = 0; i < NODES; i++)
    {
        newWeight = dt[4].costs[rcvdpkt->sourceid][rcvdpkt->sourceid] + rcvdpkt->mincost[i];
        if(newWeight<dt[4].costs[i][rcvdpkt->sourceid] && i!=4)
        {
            dt[4].costs[i][rcvdpkt->sourceid] = newWeight;
            if(newWeight < min_cost[4][i])
            {
                pku.mincost[i] = min_cost[4][i] = newWeight;
                changed = true;
            }
        }
    }

    if(changed){
        pku.destid = 1;
        tolayer2(pku);
        pku.destid = 2;
        tolayer2(pku);
        pku.destid = 3;
        tolayer2(pku);
        spc4 += 3;
    }
}

/*----------------------------------------------------
*    printdt_0
*
*    Prints distance table at node 0.
*-----------------------------------------------------*/
void printdt_0 (struct distance_table *t)
{
   printf("/t/t ----------------------/n");
   printf("/t/t      |      via     /n");
   printf("/t/t   D0 |    1     2/n");
   printf("/t/t ----|-----------/n");
   printf("/t/t     1| %3d   %3d/n", t->costs[1][1], t->costs[1][2]);
   printf("/t/t     2| %3d   %3d/n", t->costs[2][1], t->costs[2][2]);
   printf("/t/tdest 3| %3d   %3d/n", t->costs[3][1], t->costs[3][2]);
   printf("/t/t     4| %3d   %3d/n", t->costs[4][1], t->costs[4][2]);
   printf("/t/t ----------------------/n");
}

/*----------------------------------------------------
*    printdt_1
*
*    Prints distance table at node 1.
*-----------------------------------------------------*/
void printdt_1 (struct distance_table *t)
{
   printf("/t/t --------------------------/n");
   printf("/t/t      |         via     /n");
   printf("/t/t   D1 |    0     3     4/n");
   printf("/t/t ----|-----------------/n");
   printf("/t/t     0| %3d   %3d   %3d/n", t->costs[0][0], t->costs[0][3], t->costs[0][4]);
   printf("/t/t     2| %3d   %3d   %3d/n", t->costs[2][0], t->costs[2][3], t->costs[2][4]);
   printf("/t/tdest 3| %3d   %3d   %3d/n", t->costs[3][0], t->costs[3][3], t->costs[3][4]);
   printf("/t/t     4| %3d   %3d   %3d/n", t->costs[4][0], t->costs[4][3], t->costs[4][4]);
   printf("/t/t --------------------------/n");
}

/*----------------------------------------------------
*    printdt_2
*
*    Prints distance table at node 2.
*-----------------------------------------------------*/
void printdt_2 (struct distance_table *t)
{
   printf("/t/t --------------------------/n");
   printf("/t/t      |         via     /n");
   printf("/t/t   D2 |    0     3     4/n");
   printf("/t/t ----|-----------------/n");
   printf("/t/t     0| %3d   %3d   %3d/n", t->costs[0][0], t->costs[0][3], t->costs[0][4]);
   printf("/t/t     1| %3d   %3d   %3d/n", t->costs[1][0], t->costs[1][3], t->costs[1][4]);
   printf("/t/tdest 3| %3d   %3d   %3d/n", t->costs[3][0], t->costs[3][3], t->costs[3][4]);
   printf("/t/t     4| %3d   %3d   %3d/n", t->costs[4][0], t->costs[4][3], t->costs[4][4]);
   printf("/t/t --------------------------/n");
}

/*----------------------------------------------------
*    printdt_3
*
*    Prints distance table at node 3.
*-----------------------------------------------------*/
void printdt_3 (struct distance_table *t)
{
   printf("/t/t --------------------------/n");
   printf("/t/t      |         via     /n");
   printf("/t/t   D3 |    1     2     4/n");
   printf("/t/t ----|-----------------/n");
   printf("/t/t     0| %3d   %3d   %3d/n", t->costs[0][1], t->costs[0][2], t->costs[0][4]);
   printf("/t/t     1| %3d   %3d   %3d/n", t->costs[1][1], t->costs[1][2], t->costs[1][4]);
   printf("/t/tdest 2| %3d   %3d   %3d/n", t->costs[2][1], t->costs[2][2], t->costs[2][4]);
   printf("/t/t     4| %3d   %3d   %3d/n", t->costs[4][1], t->costs[4][2], t->costs[4][4]);
   printf("/t/t --------------------------/n");
}

/*----------------------------------------------------
*    printdt_4
*
*    Prints distance table at node 4.
*-----------------------------------------------------*/
void printdt_4 (struct distance_table *t)
{
   printf("/t/t --------------------------/n");
   printf("/t/t      |         via     /n");
   printf("/t/t   D4 |    1     2     3/n");
   printf("/t/t ----|-----------------/n");
   printf("/t/t     0| %3d   %3d   %3d/n", t->costs[0][1], t->costs[0][2], t->costs[0][3]);
   printf("/t/t     1| %3d   %3d   %3d/n", t->costs[1][1], t->costs[1][2], t->costs[1][3]);
   printf("/t/tdest 2| %3d   %3d   %3d/n", t->costs[2][1], t->costs[2][2], t->costs[2][3]);
   printf("/t/t     3| %3d   %3d   %3d/n", t->costs[3][1], t->costs[3][2], t->costs[3][3]);
   printf("/t/t --------------------------/n");
}


/*--------------------------------------------------------------
*    linkhandler0 & linkhandler1
*---------------------------------------------------------------*/
void linkhandler0 (int linkid, int newcost) {}
void linkhandler1 (int linkid, int newcost) {}

qipo12
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算机网络_DV算法的实现与设计
12-15
本程序很好的实现了计算机网络中的RIP的DV算法的实现，采用了C/S模式的架构，java实现，充分表现出了面向对象的思想，尤其难点是计时器的实现，采用了java内部的timer类，本project界面清楚,一目了然，内部类的包装非常到位，代码结构清晰，有注释。另外赠送上了设计文档。
【计算机网络自顶向下方法】DV算法的运行举例
wgl307293845的博客
02-08 1819
应用场合是该图顶部有三个节点的简单网络。算 法的运行以同步的方式显示出来，其中所有节点同时从其邻居接收报文，计算其新距离向 量，如果距离向量发生了变化则通知其邻居。学习完这个例子后，你应当确信该算法以异 步方式也能正确运行，异步方式中可在任意时刻出现节点计算与更新的产生/接收。 该图最左边一列显示了这3个节点各自的初始路由选择表(routing table)。例如，位 于左上角的表是节点咒的初始路由选择表。在一张特定的路由选择表中，每行是一个距离向量特别是每个节点的路由选择...
一个DV算法样例
dxongu的博客
01-03 5300
考研完事了，上传一个之前搜的计算机网络DV算法样例题： The topology of a network shown as below.Using Link State routing algorithm to calculate therouting table in the node A.        Thevectors arrive to node C as bellow: B:
计算机网络:自顶向下方法 第五章编程作业-DV算法
zzzzzec的博客
05-21 4066
DV算(<<计算机网络:自顶向下方法>>第五章编程作业) 目录 DV算(<<计算机网络:自顶向下方法>>第五章编程作业) 一.算法原理 1.1目标 1.2算法的核心思想 1.3算法的表格 １.４“更新”与“发布” 1.5注意事项 二．代码部分（以node0.c为例） 2.1初始化部分 ２.2接收到消息 2.3更改链路开销(只在node1.c和node2.c中) 三.测试结果 第一步:初始化 第二步:初始化完成,算法收敛 第三步.
DV路由选择算法实现样例
05-31
DV路由选择算法实现样例using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.IO; namespace Router { public partial class MainWindow : Form { //TXT存放路由号，端口信息 private string datapath; private StreamReader sr = null; private List routerList = null; private List rwlist; public MainWindow() {
DV算法模拟软件
11-20
【DV算法模拟软件】 在计算机网络领域，路由选择是网络通信中的关键环节，它决定了数据包如何从源节点传输到目标节点。DV算法（Distance Vector Routing Algorithm）是一种广泛应用的路由选择算法，尤其在局域网和...
DV Hop 算法
04-08
DV Hop算法，可以生成随机矩阵和误差分析。
基于麻雀算法优化的DVHop
04-12
matlab代码: 基于麻雀搜索算法改进的DV-HOP算法 内容概要：利用麻雀算法寻找未知节点到信标节点的实际距离与估计距离之间的最小误差，从而达到对未知节点位置的估计。 适合人群：对无线传感器网络（WSN）定位相关...
dv.rar_DV算法C_dv rip_静态路由
09-22
本资源"dv.rar_DV算法C_dv rip_静态路由"聚焦于RIP（Routing Information Protocol，路由信息协议）中的距离向量（Distance Vector）算法的C语言实现以及静态路由选择。下面将详细解释这两个核心概念。 首先，我们...
C语言模拟路由DV算法
11-26
来自university of Massachusetts的网络作业 框架是node0.c DVsim.h DVsim.c，其中有两个函数需要自己补充，根据自己具体的拓扑图要修改一些数据结构。
基于DV的路由算法实验（一）
Zing的博客
03-21 5363
任务一  模拟路由收敛 ======= 搬运一下上学期的计网实验 =======         已知网络拓扑如下图所示，请使用DV算法模拟该网络的迭代收敛过程。 程序要求： 使用python3编程； 使用socket编程实现分布式； 使用多个虚拟机进行验证； 每次迭代后（每隔Interval，...
DV算法——毒性逆转题目图解
weixin_47692652的博客
05-07 5265
Consider Figure 5.7. Suppose there is another router w, connected to router y and z. The costs of all links are given as follows: c(x,y) = 4, c(x,z) = 50, c(y,w) = 1, c(z,w) = 1, c(y,z) = 3. Suppose that poisoned reverse is used in the distance-vector rout
DV算法2
qipo12的专栏
05-30 467
作者：冰蓝沸点 2007年05月21日 星期一 16:50DVSim.cpp:/******************************************************************    DVsim.c     Distance Vector Routing Simulation Package**    Event driven sim
吉林大学 软件学院 计算机网络题型总结
weixin_51796629的博客
02-23 3450
吉林大学软件学院计算机网络
【计算机网络】网络层
weixin_43372187的博客
05-29 803
网络层 虚拟互联网络 IP协议使得复杂的实际网络变成一个虚拟的互连网络 IP协议可以使得网络层屏蔽底层细节而专注网络层的数据转发 IP协议解决了在虚拟网络中数据报传输路径的问题 IP数据报格式 对于IP协议的头部，前五行为固定部分，第六行可有可无，第七行为数据报，前五行每行都有32个比特，也就是四个字节，所以IP头部至少有20个字节长度。 版本 : 有 4（IPv4）和 6（IPv6）两个； 首部长度 : 占 4 位，因此最大值为 15。值为 1 表示的是 1 个 32 位字的长度，也就是 4
计算机网络慕课第五章（下）习题解答
YT学习记录
06-06 4360
1、下图所示的网络中，采用了OSPF来配置路由器。如果要从Net A到达Net B，应该选择哪条路径？ R1,R3,R5,R7 【解答】： OSPF-开放最短路径优先 可以用dijkstra算法计算。 2、某自治系统内采用 RIP 协议，若该自治系统内的路由器 R1 收到其邻居路由器 R2 的距离矢量中包含的信 息<net1，16>，则可能得出的结论是? R1不能通过R2到达net1 【解答】 RIP协议使用的是DV算法，<net1,16>表示从R1经过R2到达net1的最佳路径为
简单易懂的距离向量算法DV阐述（附伪代码）
热门推荐
湫一
11-21 1万+
算法说明 距离向量算法是一种迭代的、异步的、分布式的、能够自我终止的算法。 在计算机网络中，该算法主要用在路由选择上。本文的讨论范围就限于计网中的路由选择算法。以下展开算法解释。 异步：该算法不要求所有结点之间相互保持一致地进行操作和计算。 分布式：每个结点都只维护一张局部的路由表，每个路由结点需要从一个或者多个直接相邻的邻接结点接收某些链路信息，执行计算，然后将计算结果分发给邻接结点。 ...
计算机网络——DV和LS算法笔记
@@老胡的博客
07-27 6028
距离向量算法思路：每个节点有一张选路表（距离表），维持选路数据，随着算法进行，不断更新，直到静止。 dv算法步骤： （1）初始化 计算节点x到所有目的点y的距离向量Dx(y) 若目的点y是节点x的邻居，则Dx(y) = c(x,y )，否则，Dx(y)= ∞ 节点x的每一个邻居w到所有目的点y的距离向量为 Dw(y) = ∞ 把节点x的距离向量Dx = [Dx(y)：y在N中] （节点x到每个目的节点y的估计费用）发给每一个邻居w （2）更新距离向量 发现直接相连的链路费用变化，或收到邻居的新距离向量，更新
DV算法和距离向量算法
最新发布
06-08
在DV算法中，每个节点会周期性地向相邻节点发送自己的距离向量信息，并接收相邻节点发送的距离向量信息，通过比较不同路径的距离，选择距离最短的路径作为最优路径。DV算法的优点是实现简单，但缺点是容易出现路由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值