精华内容
下载资源
问答
  • #include<iostream> #include<vector> #include<string> #include<windows.h> #define Inifinity 65535 class NetNode { public: friend class DV; private: ... struct info {
    #include<iostream>
    #include<vector>
    #include<string>
    #include<windows.h>
    #define Inifinity 65535
    
    class NetNode {
    public:
        friend class DV;
    private:
        std::vector<std::vector<int>>direction_vector;
        struct info {
            std::string node_name;
            unsigned int node_id;
        }node_info;
    
        void InitNetNode(const int& node_number, const std::pair<std::string, int>& info) {
            node_info.node_name = info.first;
            node_info.node_id = info.second;
            direction_vector.resize(node_number);
            for (int i = 0; i < node_number; ++i) {
                direction_vector[i].resize(node_number);
                if (i == node_info.node_id) {
                    std::cout << "Please input value:";
                    for (int j = 0; j < node_number; ++j) {
                        int value;
                        std::cin >> value;
                        direction_vector[i][j] = value;
                    }
                }
                else {
                    for (int j = 0; j < node_number; ++j) {
                        direction_vector[i][j] = Inifinity;
                    }
                }
            }
            //show_value();
        }
    
        std::vector<int> return_self_value(const int& id) const {
            std::vector<int> self_value;
            for (auto& value : direction_vector[id])
                self_value.push_back(value);
            return self_value;
        }
      
        void BellmanFord_Function()
        {
            std::cout << "NetNode-" + node_info.node_name << " now is using bellmanford function to update!" << std::endl;
            for (int i = 0; i < direction_vector.size(); ++i)
            {
                if (i == node_info.node_id)
                    continue;
                direction_vector[node_info.node_id][i]
                    = get_min_value(i);
            }
        }
    
        void show_value() const {
            for (int i = 0; i < direction_vector.size(); ++i)
            {
                for (int j = 0; j < direction_vector.size(); ++j)
                {
                    std::cout << direction_vector[i][j] << " ";
                }
                std::cout << std::endl;
            }
        }
    
        int get_min_value(const int& destination)
        {
            int res = Inifinity;
            for (int i = 0; i < direction_vector.size(); ++i)
            {
                if (i == node_info.node_id)
                    continue;
                if ((direction_vector[node_info.node_id][i] + direction_vector[i][destination]) < res)
                {
                    res = direction_vector[node_info.node_id][i] + direction_vector[i][destination];
                }
            }
            return res;
        }
    };
    
    class DV {
    public:
        explicit DV(const int& netnode_number)
            :m_netnode_number(netnode_number)
        {
            InitNet();
        }
        void DV_algorithm() {
            while (true)
            {
                bool flag = false;
                for (int i = 0; i < m_netnode_number; ++i)
                {
                    if (receive_message(i)) flag = true;
                    else flag = false;
                    Sleep(1000);
                }
                if (flag)
                {
                    for (int i = 0; i < m_netnode_number; ++i)
                    {
                        m_netnode[i].BellmanFord_Function();
                        m_netnode[i].show_value();
                        Sleep(1000);
                    }
                }
                else break;
            }
        }
    
        void show_net_value() const {
            for (int i = 0; i < m_netnode_number; ++i) {
                m_netnode[i].show_value();
                std::cout << std::endl;
            }
        }
        static int index;
    private:
        std::vector<NetNode>m_netnode;
        int m_netnode_number;
    private:
        //init
        void InitNet()
        {
            for (int i = 0; i < m_netnode_number; ++i)
            {
                NetNode netnode;
                std::cout << "Please give a name for your netnode:";
                std::string name;
                std::cin >> name;
                netnode.InitNetNode(m_netnode_number, std::make_pair(name, DV::index));
                m_netnode.push_back(netnode);
                DV::index++;
            }
        }
        //update a netnode
        bool receive_message(const int& id) {
            bool flag = false;
            std::cout << "NetNode-" + m_netnode[id].node_info.node_name << " now is receiving messages!" << std::endl;
            for (int i = 0; i < m_netnode_number; ++i)
            {
                if (i == id)
                    continue;
                int column = 0;
                for (auto value : m_netnode[i].return_self_value(i)) {
                    if (m_netnode[id].direction_vector[i][column] == value)
                    {
                        column++;
                        continue;
                    }
                    m_netnode[id].direction_vector[i][column] = value;
                    column++;
                    if (!flag) flag = true;
                }
            }
            m_netnode[id].show_value();
            return flag;
        }
    };
    
    int DV::index = 0;
    
    void Test()
    {
        DV dv(3);
        dv.DV_algorithm();
        dv.show_net_value();
    }
    
    int main()
    {
        Test();
        return 0;
    }
    

    测试用例:
    在这里插入图片描述
    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 距离向量路由选择

    千次阅读 2019-11-06 21:50:43
    距离向量路由选择是通过对Bellman-Ford算法进行适当修改,找到任意两结点之间的最短路径。 ​ 先介绍一下Bellman-Ford算法: 1 Bellman-Ford算法 ​ 这个算法基于这样一个事实,如果结点 i 的所有邻站都知道到...

    距离向量路由选择

    距离向量路由选择是通过对Bellman-Ford算法进行适当修改,找到任意两结点之间的最短路径。

    先介绍一下Bellman-Ford算法:

    1 Bellman-Ford算法

    ​ 这个算法基于这样一个事实,如果结点 i 的所有邻站都知道到结点的最短距离,那么求结点 i 和结点 j 之间的最短距离就可以用结点 i 到每个邻站之间的距离分别加上该邻站到结点j的最短距离,然后再从得数中选择最小的一个。
    Bellman-Ford算法

    用以下步骤为每个结点创建一个最短距离表 :

    1. 结点和它自己之间的最短距离和代价被初始化为0。

    2. 一个结点和任何其他结点之间的最短距离被设置为无穷大。一个结点和其他任何结点之间的代价应当给定(如果两个节点之间没有直接连接,可设置为无穷大)。

    3. 然后循环执行 算法Dij = min{(ci1+D1j),(ci2+D2j),…(ciN+DNj)}

    2 距离向量路由选择算法

    1. 在距离向量路由选择中,代价通常就是跳数(即在到达终点之前通过了多少个网络)。因此任意两个邻站之间的代价被设置为1。
    2. 每当路由器从它的邻站那里接收到一些信息时,它就要异步地更新自己的路由表。换言之,每个路由器只执行了整个Bellman-Ford算法中的一部分。这个处理过程是分布式的。
    3. 在路由器更新了自己的路由表之后,应当将结果发送给它的所有邻站,以便这些邻站也能更新它们的路由表。
    4. 每个路由器至少应当保存每条路由的三个信息:目的网络、代价和下一跳。我们称完整的路由表为Table,表中的第i行为Tablei第i行的三个列分别为Tablei.dest,Tablei.cost和Tablei.next。
    5. 我们把来自邻站的一条路由信息称为一个R(记录),它只包含了两个信息:R.dest和R.cost。在收到的记录中不包含下一跳信息,因为下一跳就是发送方的源地址。

    3 计数到无穷大

    ​ 距离向量路由的缺点是:好消息传得快,坏消息传得慢。要想让路由选择协议能够正常工作,如果一条链路中断了(代价变为无穷大),那么其他所有路由器都应当立刻获知这一情况,但是在距离向量路由选择中,这是要花费一些时间的。这个问题就称为计数到无穷大(count to infinity)。需要经过多次更新才能使所有的路由器都把这条中断链路的代价记录为无穷大。

    二结点循环问题:

    二结点循环问题

    为了解决这种不稳定性的几种方法:

    1. 定义无穷大:距离向量协议一般把16定义为无穷大,即16跳为不可达,但是这也意味着距离向量不能用于大系统。在各个方向上,网络的大小都不能超过15跳。
    2. 分割范围:如果结点B根据其路由表认为到达X的最佳路由要经过A,那么它就不需要再把到X的路由通告给A了,因为这个信息就是从A来的(A已经知道了)。从结点A得到信息,修改后再发回给A,这就是产生混乱的根源。所以,结点B在发送路由表给A之前要删除路由表中下一跳为A的路由信息。在这种情况下,结点A保留到X的距离为无穷大。在此之后,当结点A将其路由表发送给B时,结点B也就更正了它的路由表。系统在第一次更新后就变稳定了,因为结点A和B都知道了X是不可达的。
    3. 分割范围和毒性逆转:使用分割范围策略有一个缺点。通常,距离向量协议使用一个计时器,若长时间没有关于某个路由的消息,就要从路由表中删除这个路由。在前面描述的场景中,当结点B在它给A的通告中删除了到X的路由时,结点A并不能猜出这是由于分割范围策略(因为信息的来源是A),还是因为B最近一直都没有收到有关X的任何消息。分割范围策略可以与毒性逆转(poison reverse)策略组合起来使用。结点B可以仍然通知关于X的数值,但如果信息源是A,就把距离换成为无穷大(16)作为一种警告:“不要使用这个数值,我所知道的关于这条路由的信息来自于你。”

    三结点不稳定性

    ​ 分割范围和毒性逆转可以用于避免二结点的不稳定性,但如果是三个结点之间,稳定性仍然无法保证。

    三结点不稳定问题

    展开全文
  • 首先它询问节点的数量,然后它生成一个节点分布在空间中并且... 然后它根据维基百科链接中给出的理论解释使用距离矢量路由算法计算最短路径: “ http://en.wikipedia.org/wiki/Distance-vector_routing_protocol ”。
  • 距离向量路由算法

    千次阅读 2018-11-13 22:07:56
    如图所示网络拓扑,所有路由器均采用距离向量路由算法计算到达两个子网的路由(注:到达子网的路由度量采用跳步数)。    假设路由表结构如下表所示。 目的网络 接口 请回答下列问题: ...

    如图所示网络拓扑,所有路由器均采用距离向量路由算法计算到达两个子网的路由(注:到达子网的路由度量采用跳步数)。                                              

     

    假设路由表结构如下表所示。

    目的网络

    接口

    请回答下列问题:

    (1)若所有路由器均已收敛,请给出R1的路由表,要求包括到达图中所有子网的路由,且路由表中的路由项尽可能少。

    (2)在所有路由器均已收敛的状态下,R3突然检测到子网192.168.1.128/26不可到达,若接下来R2和R3同时向R1交换距离向量,则R1更新后的路由表是什么?更新后的R1距离向量是什么?

    答案:(1)R1的路由表:

        目的网络            接口

    192.168.1.0/24          S1(2分)

    192.168.1.192/26        E0(2分)

    192.168.2.0/23          S0(2分)

    (2)R1更新后的路由表:

        目的网络            接口

    192.168.1.0/25          S1(2分)

    192.168.1.128/26        S0(2分)

    192.168.1.192/26        E0(2分)

    192.168.2.0/23          S0(2分)

        R1的距离向量:

    192.168.1.0/25          2(2分)

    192.168.1.128/26        3(2分)

    192.168.1.192/26        1(2分)

    192.168.2.0/23          2(2分)   

    展开全文
  • 距离向量路由算法模拟

    热门讨论 2010-02-08 09:13:22
    模拟路由算法,自己初始化网络拓扑,显示各路由器路由表变化。
  • 用弗洛伊德最短路径,实现的距离向量路由算法
  • 距离向量路由算法的Java模拟

    千次阅读 2016-09-01 00:49:45
    实验内容:模拟距离向量路由算法的路由表交换过程,演示每轮交换后路由表的变化。基本要求(动态生成网络拓扑图,节点间的距离随机生成。从初始路由表开始,进行交换路由表,演示每轮交换后的路由表的变化。观察和...

    实验内容与实现原理;
    实验内容:模拟距离向量路由算法的路由表交换过程,演示每轮交换后路由表的变化。基本要求(动态生成网络拓扑图,节点间的距离随机生成。从初始路由表开始,进行交换路由表,演示每轮交换后的路由表的变化。观察和讨论多少轮交换后路由表稳定)。
    实现原理:初始时设定站点个数,每一个站点附带一个表格来记录其余的站点以及距离,并用随机数产生站点之间距离记入表格(产生距离是要考虑到是否相邻的情况)。在所有的距离都产生之后,就用循环对每一个站点的每一个距离与相邻结点到目标结点距离加上当前结点到相邻结点距离之和来进行比较,如果当前记录的值是较大的一个,则更新记录。并设置一个标志位,标志位初始值设为0,若发生了更新行为,则将标志位改为1,。若当前这一轮循环之后的标志位仍为0,则说明已经达到了稳定状态。输出最终结果,完成算法。


    窗体类:
    import java.awt.GridLayout;
    import java.awt.Image;
    import javax.swing.*;
    public class Myframe extends JFrame{
    private GridLayout gd=new GridLayout(4,1,10,10);
    private JTable t1=new JTable(8,8);//八行八列
    private JTextField j1=new JTextField(“初始时距离记录如下”);
    private JTable t2=new JTable(8,8);//八行八列
    private JTextField j2=new JTextField(“稳定后距离记录如下”);
    public Myframe(Routing array[],Routing b[]){
    this.setLayout(gd);
    this.setTitle(“距离向量路由算法”);
    this.setSize(800, 800);
    t1.setSize(200, 200);
    t2.setSize(200,200);
    try{
    for(int i=0;i<7;i++){
    t1.setValueAt((char)(i+’a’), 0, i+1);
    t1.setValueAt((char)(i+’a’), i+1, 0);
    t2.setValueAt((char)(i+’a’), 0, i+1);
    t2.setValueAt((char)(i+’a’), i+1, 0);
    }
    for(int i=1;i<8;i++)
    for(int j=1;j<8;j++){
    t1.setValueAt(b[i-1].dis[j-1], i, j);
    t2.setValueAt(array[i-1].dis[j-1], i, j);
    }
    }catch(Exception e){
    e.printStackTrace();
    }
    this.add(j1);
    this.add(t1);
    this.add(j2);
    this.add(t2);

    }
    }


    路由节点类
    public class Routing {
    protected char m;
    protected char[] name=new char[100];
    protected int[] dis=new int[100];
    protected char[] next=new char[100];
    public Routing(char a){
    m=a;
    for(int i=0;i<100;i++){
    dis[i]=0;
    }
    }
    }
    路由算法类:
    public class suanfa {
    Routing[] arr=new Routing[7];
    public static Routing[] create(Routing array[]){//随机生成距离
    for(int i=0;i<7;i++)
    for(int j=0;j<7;j++){
    if(i==j)
    array[i].dis[j]=0;
    else{
    if(array[i].dis[j]==0){
    array[i].dis[j]=(int)(Math.random()*50);
    if(array[i].dis[j]>40||array[i].dis[j]==0){//这种情况视为不相邻把距离设为一个很大的值
    array[i].dis[j]=1000;
    array[j].dis[i]=1000;
    } }
    }
    array[i].name[j]=array[j].m;
    array[i].next[j]=array[j].m;
    }
    for(int n=0;n<7;n++){
    System.out.println(“这是初始值”);
    System.out.println(“这是结点”+array[n].m+”的当前路由表”);
    for(int e=0;e<7;e++){
    System.out.println(array[n].name[e]+” “+array[n].dis[e]+”下一跳地址是”+array[n].next[e]);
    }
    }
    return array;
    }
    public static Routing[] exchange(Routing array[]){//检查是否有更小距离进行修正
    int ex=0,count=0;
    while(true){
    for(int i=0;i<7;i++)
    for(int j=0;j<7;j++){
    for(int m=0;m<7;m++){
    if(array[i].dis[m]==1000)
    continue;//不相邻的结点不能交换路由表
    if(array[i].dis[j]>array[i].dis[m]+array[m].dis[j]){
    array[i].dis[j]=array[i].dis[m]+array[m].dis[j];
    array[i].next[j]=array[m].m;
    ex=1;
    }}}
    count++;
    for(int n=0;n<7;n++){
    System.out.println(“这是第”+count+”轮的结果”);
    System.out.println(“这是结点”+array[n].m+”的当前路由表”);
    for(int e=0;e<7;e++){
    System.out.println(array[n].name[e]+” “+array[n].dis[e]+”下一跳地址是”+array[n].next[e]);
    }
    }
    if(ex==0){
    System.out.println(“已经达到稳定状态,一共运行了”+count+”轮”);
    return array;
    }
    ex=0;
    }
    }
    public static void main(String[] args){
    try{
    Routing[] arr=new Routing[7];
    Routing[] b=new Routing[7];
    arr[0]=new Routing(‘a’);
    arr[1]=new Routing(‘b’);
    arr[2]=new Routing(‘c’);
    arr[3]=new Routing(‘d’);
    arr[4]=new Routing(‘e’);
    arr[5]=new Routing(‘f’);
    arr[6]=new Routing(‘g’);
    b[0]=new Routing(‘a’);
    b[1]=new Routing(‘b’);
    b[2]=new Routing(‘c’);
    b[3]=new Routing(‘d’);
    b[4]=new Routing(‘e’);
    b[5]=new Routing(‘f’);
    b[6]=new Routing(‘g’);
    arr=create(arr);
    for(int i=0;i<7;i++){
    b[i].m=arr[i].m;
    for(int j=0;j<7;j++){
    b[i].dis[j]=arr[i].dis[j];
    b[i].name[j]=arr[i].name[j];

        }}
        arr=exchange(arr);
        Myframe mf=new Myframe(arr,b);
        mf.setVisible(true);
       }catch(Exception e){
           e.printStackTrace();
       }
    

    }
    }
    在本次模拟实验中,初始状态是随机生成的,然后由算法进行路径距离优化,将最终优化的结果在窗体上显示出来。实际上,在每一次的交换优化中,我都将结果在控制台输出了,比较繁琐,不过这也不是我们所关心的。

    展开全文
  • 基本概念 距离向量路由算法 链路状态路由选择算法 其他路由选择算法
  • 路由选择算法在网络路由器中运行、交换和计算信息,用这些信息配置转发表。主机通常直接与一台路由器相连接,该路由器即为该主机的默认路由器,又称为该主机的第一跳路由器。每当主机发送一个分组时,该分组被传送给...
  • 【2016】408联考真题(距离-向量路由算法

    万次阅读 多人点赞 2018-04-02 13:32:16
    该子网采用距离向量路由算法,下面的向量刚刚到达路由器C,来自B的向量为(5,0,8,12,6,2);来自D的向量为(16,12,6,0,9,10);来自E的向量为(7,6,3,9,0,4)。经过测量,C到B,D,E的延迟分别是6,3,5.那么C到达所有结点的...
  • RIP是一种基于距离向量路由选择协议 RIP的距离就是指的跳数,没经过一个路由,就是一跳,RIP允许一跳路径最多经过15个路由器,所以16个的话就相当于不可以到达了 RIP协议的特点: 1:仅和相邻的路由进行交换...
  • RIP是指路由信息协议,基于距离向量算法;OSPF是指开放最短路径优先协议,基于链路状态算法。 D-V 算法中,每个节点只需要维护自身的距离向量,且只需要与自己相连的链路的状态,需要的存储空间小;而L- S 算法中...
  • 距离向量路由相关原理及实现

    千次阅读 2018-11-19 23:48:29
    一、距离矢量路由协议的特点 ...每台路由器都必须在将从邻居学到的路由转发给其它路由器之前,运行路由算法,所以网络的规模越大,其收敛速度越慢 3、更新的是“路由条目”,一条重要的链路如果发生变化,意味...
  • Java平台上的距离向量路由协议的模拟程序。提供给定的配置文件(ConfigA.txt,包含相邻路由的端口号和距离)时,自动计算出网络中到达各个路由的距离。当路由挂起或关闭时,其它路由可以检测到路由点的消失并重新...
  • 一、路由选择协议分类、 二、RIP 协议、 三、RIP 协议 信息交换、 四、距离向量算法、 五、距离向量算法 计算示例、 六、距离向量算法 计算示例 2、
  • 基于距离向量算法的rip协议的实现,C++代码,运行环境VS2005
  • java实现基于距离向量算法 路由协议

    千次阅读 2016-11-23 09:28:39
    算法就不多说了,该程序实现的功能:首先你要将网络结构转化成邻接矩阵,每个路由器对应一行,若路由器m与网络n直接相连,则m行n列为1,否则为0 该程序的路由器和网络都从0开始编号 首先创建Table类,代表路由器的...
  • 路由算法与路由协议概述① 路由算法的分类② 分层次的路由选择协议二. RIP协议和距离向量算法① RIP协议定义② RIP协议:交换对象、交换周期、交换内容③ 距离向量算法例题1例题2④ RIP协议的报文格式⑤ RIP协议:...
  • 距离向量路由算法(例题) 如图子网中采用距离向量算法,C节点路由器收到B节点的距离向量为(5,0,8,12,6,2),收到D的向量为(16,12,6,0,9,10),收到E向量为(7,6,3,9,0,4),经过测量,C节点到B、...
  • 转自路由算法距离矢量算法和链路状态算法 &nbsp; &nbsp; &nbsp; &nbsp; 我们之前说了,路由器需要对于每一对端端节点都要寻找出一个最佳的路径,比如说最小链路成本的路径。路由算法...
  • 实现了计算机网络中距离向量(DV)算法; 开发语言:C 开发环境:VC++6.0 内有整个工程文件,可直接运行
  • 距离向量算法

    万次阅读 多人点赞 2019-06-08 20:12:10
    算法执行步骤 从相邻的 X 路由器接收发送过来的 RIP 报文 将该 RIP 报文中的下一跳地址修改为 X,且跳数增加 1 对每个项目执行如下步骤 a.若原路由表没有 RIP 中的目的网络 N,直接添加到原路由表中 b.若原路由表中...
  • 计算机网络网络层之距离向量路由算法(1) TIPS:知识出自哈尔滨工业大学李全龙老师的课程讲解。 Bellman-Ford方程(动态规划) 令: dx(y):=从x到y最短路径的费用(距离) d_x(y):=从x到y最短路径的费用(距离) ...
  • 距离向量路由算法及举例

    千次阅读 2013-10-19 22:06:45
    距离向量路由算法(Bellman-Ford Routing Algorithm),也叫做最大流量演算法(Ford-Fulkerson Algorithm),其被距离向量协议作为一个算法,如RIP, BGP, ISO IDRP, NOVELL IPX。使用这个算法的路由器必须掌握这个距离表...
  • java多线程实现距离向量路由算法

    热门讨论 2011-04-07 15:49:54
    作为一个实验课题,本项目实现了应用java多线程来实现距离向量算法,可以对此算法深入的理解
  • 距离向量算法模拟

    2014-06-29 14:52:55
    使用java多线程模拟距离向量路由选路算法
  • 一、RIP协议 二、RIP协议的报文格式 三、RIP协议的特点(RIP协议好消息传得快,坏消息传得慢) 四、距离向量算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,717
精华内容 3,886
关键字:

距离向量路由选择算法