距离向量路由算法的Java模拟

实验内容与实现原理；
实验内容：模拟距离向量路由算法的路由表交换过程，演示每轮交换后路由表的变化。基本要求（动态生成网络拓扑图，节点间的距离随机生成。从初始路由表开始，进行交换路由表，演示每轮交换后的路由表的变化。观察和讨论多少轮交换后路由表稳定）。
实现原理：初始时设定站点个数，每一个站点附带一个表格来记录其余的站点以及距离，并用随机数产生站点之间距离记入表格（产生距离是要考虑到是否相邻的情况）。在所有的距离都产生之后，就用循环对每一个站点的每一个距离与相邻结点到目标结点距离加上当前结点到相邻结点距离之和来进行比较，如果当前记录的值是较大的一个，则更新记录。并设置一个标志位，标志位初始值设为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();
   }

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