http://www.csanimated.com/animation.php?t=Bellman-Ford_algorithm

 1 procedure BellmanFord(list vertices, list edges, vertex source)
 2    // This implementation takes in a graph, represented as lists of vertices
 3    // and edges, and modifies the vertices so that their distance and
 4    // predecessor attributes store the shortest paths.
 5 
 6    // Step 1: Initialize graph
 7    for each vertex v in vertices:
 8        if v is source then v.distance := 0
 9        else v.distance := infinity
10        v.predecessor := null
11    
12    // Step 2: relax edges repeatedly
13    for i from 1 to size(vertices)-1:       
14        for each edge uv in edges: // uv is the edge from u to v
15            u := uv.source
16            v := uv.destination             
17            if v.distance > u.distance + uv.weight:
18                v.distance := u.distance + uv.weight
19                v.predecessor := u
20 
21    // Step 3: check for negative-weight cycles
22    for each edge uv in edges:
23        u := uv.source
24        v := uv.destination
25        if v.distance > u.distance + uv.weight:
26            error "Graph contains a negative-weight cycle"
27 

An implementation from wiki
 1 #include <limits.h>
 2 #include <stdio.h>
 3 #include <stdlib.h>
 4 
 5 /* Let INFINITY be an integer value not likely to be
 6    confused with a real weight, even a negative one. */
 7 #define INFINITY ((1 << 14)-1)
 8 
 9 typedef struct {
10     int source;
11     int dest;
12     int weight;
13 } Edge;
14 
15 void BellmanFord(Edge edges[], int edgecount, int nodecount, int source)
16 {
17     int *distance = malloc(nodecount * sizeof *distance);
18     int i, j;
19 
20     for (i=0; i < nodecount; ++i)
21       distance[i] = INFINITY;
22     distance[source] = 0;
23 
24     for (i=0; i < nodecount; ++i) {
25        int somethingchanged = 0
26        for (j=0; j < edgecount; ++j) {
27             if (distance[edges[j].source] != INFINITY) {
28                 int new_distance = distance[edges[j].source] + edges[j].weight;
29                 if (new_distance < distance[edges[j].dest]) {
30                   distance[edges[j].dest] = new_distance;
31                   somethingchanged = 1;
32                 } 
33             }
34         }
35         /* if one iteration had no effect, further iterations will have no effect either */
36         if (!somethingchanged) break;
37     }
38 
39     for (i=0; i < edgecount; ++i) {
40         if (distance[edges[i].dest] > distance[edges[i].source] + edges[i].weight) {
41             puts("Negative edge weight cycles detected!");
42             free(distance);
43             return;
44         }
45     }
46 
47     for (i=0; i < nodecount; ++i) {
48         printf("The shortest distance between nodes %d and %d is %d\n",
49             source, i, distance[i]);
50     }
51 
52     free(distance);
53     return;
54 }
55 
56 int main(void)
57 {
58     /* This test case should produce the distances 2, 4, 7, -2, and 0. */
59     Edge edges[10= {{0,15}, {0,28}, {0,3-4}, {1,0-2},
60                       {2,1-3}, {2,39}, {3,17}, {3,42},
61                       {4,06}, {4,27}};
62     BellmanFord(edges, 1054);
63     return 0;
64 }