# Java C 实现Bellman-ford算法

``````package com.cn.tree;

public class MyException extends Exception {
private static final long serialVersionUID = 1L;
public MyException(String str) {
super(str);
}
public MyException() {}
}
``````

``````package com.cn.graph;

import com.cn.tree.MyException;

/**
* 很明显时间复杂度为O(VE),因为每一次需要对边进行松弛，所以我们采用保存边的方式来存储图的的信息。
* p保存的是前驱节点，d保存的是源点到每一个点的最短距离。我们最后又做了一次判断，如果还有可以松弛
* 的边，那么可以保证的是图中有负权的环存在，这样的话就没有最短路径只说了，可以无限小。
*
* @author daijope
*
*/
public class BellmanFord {
private static final int m = 10000;
public static void main(String[] args) throws MyException {

Adge[] as = new Adge[]{a1, a2, a3, a4, a5, a6, a7, a8};

int[] d = new int[5];
int[] p = new int[5];
d[0] = 0;
p[0] = 0;
for (int i = 1; i < d.length; i++) {
d[i] = m;
p[i] = -1;
}
bellman_Ford(as, d, p);

for (int i = 0; i < d.length; i++) {
System.out.println(d[i]);
}
}
private static void bellman_Ford(Adge[] as, int[] d, int[] p) throws MyException {
for(int i = 1; i < d.length; i++) {
for (int j = 0; j < as.length; j++) {
if (d[as[j].getV()] > d[as[j].getU()] + as[j].getW()) {
d[as[j].getV()] = d[as[j].getU()] + as[j].getW();
p[as[j].getV()] = as[j].getU();
}
}
}
for (int j = 0; j < as.length; j++) {
if (d[as[j].getV()] > d[as[j].getU()] + as[j].getW()) {
throw new MyException("有负环");
}
}

}
}
private int u;
private int v;
private int w;

public Adge(int u, int v, int w) {
this.u = u;
this.v = v;
this.w = w;
}

public int getU() {
return u;
}

public void setU(int u) {
this.u = u;
}

public int getV() {
return v;
}

public void setV(int v) {
this.v = v;
}

public int getW() {
return w;
}

public void setW(int w) {
this.w = w;
}

}

``````

c语言实现：

``````#include<stdio.h>
#define MAXVALUE 10000
typedef struct node
{
int u;
int v;
int w;
};
bool BELLMAN_FORD(node G[])
{

int dis[5],pre[5],p[5];
int i,j,k;
for(i=0;i<=4;i++)
{
dis[i]=MAXVALUE;
pre[i]=-1;
p[i]=1;
}
dis[G[0].u]=0;
for(j=1;j<=4;j++)
{
for(i=0;i<=7;i++)
{
if(dis[G[i].v]>dis[G[i].u]+G[i].w)
{
dis[G[i].v]=dis[G[i].u]+G[i].w;
pre[G[i].v]=G[i].u;
}
}
}
for(i=1;i<=7;i++)
{
if(dis[G[i].v]>dis[G[i].u]+G[i].w)
return false;
}
for(i=0;i<=7;i++)
{
if(p[G[i].v]==1)
{
printf("%d   %d\n",G[i].v,dis[G[i].v]);
k=G[i].v;
p[G[i].v]=0;
while(pre[k]!=-1)
{
printf("%d   \n",pre[k]);
k=pre[k];
}
}
}
return true;
}
int main()
{
node G[8];
G[0].u=0;
G[0].v=1;
G[0].w=-1;
G[1].u=0;
G[1].v=2;
G[1].w=3;
G[2].u=1;
G[2].v=2;
G[2].w=3;
G[3].u=1;
G[3].v=3;
G[3].w=2;
G[4].u=1;
G[4].v=4;
G[4].w=2;
G[5].u=3;
G[5].v=1;
G[5].w=1;
G[6].u=3;
G[6].v=2;
G[6].w=5;
G[7].u=4;
G[7].v=3;
G[7].w=-3;
BELLMAN_FORD(G);
getchar();

}
//O(VE)
``````

原文作者：Bellman - ford算法
原文地址: https://blog.csdn.net/daijope/article/details/6781029
本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。