根据算法导论上的说明：该算法可以说很简单，对每个节点维护两个信息，一个是源节点到该节点的距离，另一个是到该节点的前一个节点。也即前驱。假设当前用距离表A来保存所有点的这两个信息。假设有n个节点 算法分为三步步走。

第一步初始化A，A中所有距离均为无穷大，且前驱为空 第二步，计算距离。对图中的每条边（u,v,w)都进行relax操作。其意义是，测试是否可以对从源节点s到v的最短路径进行改善。方法是：利用A中维护从源节点到任意节点v的距离，若从节点u到v的距离比A中的小，则更新A中的距离为这个更小的值，且A中v节点的前驱也更新为u。这里在更新A中的节点V时，边（u,V）应该是节点v的一条弧（无向图中为以v为一端短点的边，有向图中则为以v为尾 的弧）。 第三步，检查是否存在权值为负的边，若存在，则不存在解决方案。 最后根据A中的信息构建路径。

最后自己硬着头皮写了一上午，调各种错误，之后调出正确结果之后才算有了一些自己的理解。 这个算法可以说
采用的思想是遍历比较。
对图中的每一个节点进行如下操作：

遍历与该节点u相邻的每一条边（u,v)，若从源点经由u到v比从源点到v的距离短，则用这个短的距离来更新距离值，并且设置节点v的前驱为节点u。 当对所有的节点都进行了如上述所说的操作之后，最后得到的距离表和前驱表即可构建路径和距离信息。

下面是我用python写的一个代码示例，写的很粗糙。

import numpy as np
dist=np.array([[0,1,1,0.5,0,0],[1,0,0,1,1,0],[1,0,0,1,1,1],[0.5,1,1,0,1,0],[0,1,1,1,0,1],[0,0,1,0,1,0]])
def bf(adjacent_array,source):
    weight = adjacent_array
    node_num = len(adjacent_array[0])
    path = list(range(node_num))
    distance = [float("inf") for i in range(node_num)]
    distance[source-1] = 0

    i = 0
    while i < node_num:
        j = i
        while j < node_num:
            if weight[i][j]:
                if distance[i]+weight[i][j]<distance[j]:
                    distance[j] = distance[i]+weight[i][j]
                    path[j] = i
            j += 1
        i += 1
    i = 0
    while i < node_num:
        path_to = [i+1]
        j = i
        while j != source-1:
            path_to.insert(0,path[j]+1)
            j = path[j]
        print("the path to %d is:"%(i+1))
        print(path_to)
        i += 1
    print(distance)
bf(dist,1)

<< 运行结果如下
the path to 1 is:
[1]
the path to 2 is:
[1, 2]
the path to 3 is:
[1, 3]
the path to 4 is:
[1, 4]
the path to 5 is:
[1, 4, 5]
the path to 6 is:
[1, 3, 6]
[0, 1.0, 1.0, 0.5, 1.5, 2.0]