基于SDN的最短路径算法(迪杰斯特拉)dijkstra

static int hop[] = new int[maxnum]; //当前节点到源节点的跳数
public static void Dijkstra(int n,int v,int b,int dist[],int mprev[],int c[][]){
boolean s[] = new boolean[maxnum];
tot++;
tmp = mprev[tmp];
}
que[tot] = v;
for(int i = tot;i>=1;i--){
if(i != 1){
int num = que[i];
try {
out.write(String.valueOf(num).getBytes());
out.write(",".getBytes());
least = c[u][j]; //最得最小的带宽值
if((!s[j]) &&(least > dist[j])){ //如果当前节点到源点的路径中的最小带宽过小，更新当前节点最小带宽及路径
hop[j] = hop[u]+1;
mprev[j] = u;
dist[j] = least;
}
else if((!s[j]) &&(least == dist[j])){ //如果相等，则比较跳数，跳数小者成为当前节点的路径
c[i][j] = minint;
}
}
for(int i=1;i<=LineNum;i++){
String Readvstr = (String) vstr.get(i-1);
String[] vstrdata = Readvstr.split("\\,");
int firstvstr = Integer.parseInt(vstrdata[0]);
其中input.txt的内容如下:
leftnodeID,rightnodeID,bandwidth
1,3,100
1,4,100
2,3,100
2,4,100
3,4,100
3,5,100
3,6,100
4,5,100
4,6,100
5,6,100
5,7,100
5,8,100
6,7,100
6,8,100
;
srcNodeID,dstNodeID,bandwidth
1,7,90
3,8,90
zhlsdn.exe执行完成后，输出的output.txt文件内容如下：
1,3,5,7
3,5,8
更改input.txt中的数据如下：
leftnodeID,rightnodeID,bandwidth
1,3,80
1,4,100
2,3,60
2,4,100
3,4,100
3,5,95
3,6,100
while(true){
str = in.readLine();
if(str.isEmpty()){
break;
}
vstr.add(str);
LineNum++;
}
in.readLine();
in.readLine();
while(true){
str = in.readLine();
if(str == null)
c[secondvstr][firstvstr] = thirdvstr;
}
}
for(int i=1;i<=NodeNum;i++){
dist[i] = minint;
hop[i] = minint;
}
int src,dst,bdw;
OutputStream out = new FileOutputStream(output,false);
程序中的Dijkstra()方法是dijkstra最短路径算法的实现，我们先计算各条路径的最低带宽约束（指两条直连节点之间的带宽）并选择最低带宽约束大的那条路径作为最短路径；只有当两条路径的最低带宽相等时，我们才比较两条路径经过节点的跳数，并取跳数小的那条路径为最优路径。
程序流程图如下图所示：
图1：主程序流程图图2：searchpath方法流程图
int secondvstr = Integer.parseInt(vstrdata[1]);
int thirdvstr = Integer.parseInt(vstrdata[2]);
if(thirdvstr > c[firstvstr][secondvstr]){
c[firstvstr][secondvstr] = thirdvstr;
图3：dijkstra算法流程图
三.实验步骤
采用java语言编写zhlsdn.java文件实现上面的流程图，将zhlsdn.java文件转换为zhlsdn.exe文件（zhlsdn.exe运行需要jdk支持），在命令行输入如下命令：
zhlsdn.exe input.txt output.txt
如下图所示，
for(int i=1;i<=n;i++){
dist[i] = c[v][i];
s[i] = false;
if(dist[i] == minint)
mprev[i] = 0;
else {
mprev[i] = v;
hop[i] = 1;
}
}
dist[v] = maxint;
s[v] = true;
for(int i=2;i<=n;i++){
基于SDN的最短路径算法（迪杰斯特拉）
一.实验要求
下面为示例拓扑图，我们要用算法计算出id为1设备到id为7的设备和设备id为2到ide为8设备的最优路线。
图示：组网拓扑
说明：此处拓扑图仅作为一个举例，路由算法程序应该能够处理各种拓扑情况，只要输入数据符合格式要求。程序应能够处理不同的Input.txt数据，并且可以处理带宽资源约束（input第一段最后属性）和路径需求（input第二段最后属性）。
int secondstr = Integer.parseInt(strdata[1]);
if(firststr<secondstr)
NodeNum = secondstr;
else
NodeNum = firststr;
for(int i=1;i<=NodeNum;i++){
for(int j=1;j<=NodeNum;j++){
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
String input = args[0];
String output = args[1];
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(new File(input))));
if(hop[j]>hop[u]+1){
hop[j] = hop[u]+1;
mprev[j] = u;
dist[j] = least;
}
}
}
}
}
public static void searchPath(int mprev[],int v,int u,String output) throws FileNotFoundException{
out.write("".getBytes());
out.close();
for(int i=1;i<=dstr.size();i++){
String Readvstr = (String) dstr.get(i-1);
String sdstr[] = Readvstr.split(",");
src = Integer.parseInt(sdstr[0]);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
else{
try {
out.write(String.valueOf(que[i]).getBytes());
out.write("\r\n".getBytes());
二．实验环境及思路
算法用java语言实现，采用非常典型的dijkstra最短路径算法，根据带宽约束及带宽需求寻找最优路径，当两条路径上的带宽约束最小值相等时，则取经过交换机的跳数小的那条路径为最优路径。
首先读取input.txt中的数据（带宽约束、源节点、目的节点和带宽需求bdw），调用Dijkstra()方法计算各目的节点到源节点的最短路径，计算更新dist[]、mprev[]、hop[]、c[][]中的数据（dist[]数组用来存放整条路径上的最低带宽，mprev[]数组用来存放当前节点到源节点的下一跳节点，hop[]存放当前节点到源节点的跳数，c[][]存放两节点间的带宽），最后调用searchPath()方法查找目的节点到源节点的整条路径，并输出到output.txt文件中。
String str = new String();
int NodeNum = 0;
int LineNum = 0;
Vector<String> vstr = new Vector<String>();
Vector<String> dstr = new Vector<String>();
str = in.readLine();
OutputStream out = new FileOutputStream(output,true);
int que[] = new int[maxnum];
int tot = 1;
que[tot] = u;
tot++;
int tmp = mprev[u];
while(tmp != v){
que[tot] = tmp;
int tmp = b;
int u = v;
for(int j=1;j<=n;j++){
if((!s[j]) && dist[j]>=tmp){
u = j;
tmp = dist[j];
}
}
s[u]= true;
for(int j=1;j<=n;j++){
int least = dist[u];
if(c[u][j]<dist[u])
static int dist[] = new int[maxnum]; //当前路径中的最小带宽
static int mprev[] = new int[maxnum]; //当前节点的前一跳节点
static int c[][] = new int[maxnum][maxnum]; //两个节点之间的带宽
dst = Integer.parseInt(sdstr[1]);
bdw = Integer.parseInt(sdstr[2]);
Dijkstra(NodeNum,src,bdw,dist,mprev,c);
searchPath(mprev,src,dst,output);
}
}
}
附录：zhlsdn.java
import java.io.*;
import java.util.Vector;
public class zhlsdn {
final static int maxnum = 100;
final static int minint = 0;
final static int maxint = 999999;
4,5,80
4,6,110
5,6,90
5,7,120
5,8,100
6,7,95
6,8,100
;
srcNodeID,dstNodeID,bandwidth
1,7,90
3,8百度文库90
输出的output.txt的内容如下：
1,4,6,8,5,7
3,6,8
四.实验结论：zhlsdn.java实现了采用dijkstra最短路径算法并结合带宽需求计算最优路径及输出的功能，达到了实验的要求。
break;
else if(str.isEmpty())
break;
dstr.add(str);
}
String LastLine = (String) vstr.lastElement();
String[] strdata = LastLine.split("\\,");
int firststr = Integer.parseInt(strdata[0]);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
try {
out.close();
} catch (IOException e) {
// TODO Auto-generated catch block