最短路径算法的命令式、函数式版本对比分析

C版本（来自 最短路径算法—Dijkstra(迪杰斯特拉)算法分析与实现(C/C++)）

/***************************************
* About:    有向图的Dijkstra算法实现
* Author:   Tanky Woo
* Blog:     www.WuTianQi.com
***************************************/
   
#include <iostream>
using namespace std;
   
const int maxnum = 100;
const int maxint = 999999;
   
   
void Dijkstra(int n, int v, int *dist, int *prev, int c[maxnum][maxnum])
{
    bool s[maxnum];    // 判断是否已存入该点到S集合中
    for(int i=1; i<=n; ++i)
    {
        dist[i] = c[v][i];
        s[i] = 0;     // 初始都未用过该点
        if(dist[i] == maxint)
            prev[i] = 0;
        else
            prev[i] = v;
    }
    dist[v] = 0;
    s[v] = 1;
   
    // 依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
    // 一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
    for(int i=2; i<=n; ++i)
    {
        int tmp = maxint;
        int u = v;
        // 找出当前未使用的点j的dist[j]最小值
        for(int j=1; j<=n; ++j)
            if((!s[j]) && dist[j]<tmp)
            {
                u = j;              // u保存当前邻接点中距离最小的点的号码
                tmp = dist[j];
            }
        s[u] = 1;    // 表示u点已存入S集合中
   
        // 更新dist
        for(int j=1; j<=n; ++j)
            if((!s[j]) && c[u][j]<maxint)
            {
                int newdist = dist[u] + c[u][j];
                if(newdist < dist[j])
                {
                    dist[j] = newdist;
                    prev[j] = u;
                }
            }
    }
}
   
void searchPath(int *prev,int v, int u)
{
    int que[maxnum];
    int tot = 1;
    que[tot] = u;
    tot++;
    int tmp = prev[u];
    while(tmp != v)
    {
        que[tot] = tmp;
        tot++;
        tmp = prev[tmp];
    }
    que[tot] = v;
    for(int i=tot; i>=1; --i)
        if(i != 1)
            cout << que[i] << " -> ";
        else
            cout << que[i] << endl;
}
   
int main()
{
    freopen("input.txt", "r", stdin);
    // 各数组都从下标1开始
    int dist[maxnum];     // 表示当前点到源点的最短路径长度
    int prev[maxnum];     // 记录当前点的前一个结点
    int c[maxnum][maxnum];   // 记录图的两点间路径长度
    int n, line;             // 图的结点数和路径数
   
    // 输入结点数
    cin >> n;
    // 输入路径数
    cin >> line;
    int p, q, len;          // 输入p, q两点及其路径长度
   
    // 初始化c[][]为maxint
    for(int i=1; i<=n; ++i)
        for(int j=1; j<=n; ++j)
            c[i][j] = maxint;
   
    for(int i=1; i<=line; ++i)
    {
        cin >> p >> q >> len;
        if(len < c[p][q])       // 有重边
        {
            c[p][q] = len;      // p指向q
            c[q][p] = len;      // q指向p，这样表示无向图
        }
    }
   
    for(int i=1; i<=n; ++i)
        dist[i] = maxint;
    for(int i=1; i<=n; ++i)
    {
        for(int j=1; j<=n; ++j)
            printf("%8d", c[i][j]);
        printf("
");
    }
   
    Dijkstra(n, 1, dist, prev, c);
   
    // 最短路径长度
    cout << "源点到最后一个顶点的最短路径长度: " << dist[n] << endl;
   
    // 路径
    cout << "源点到最后一个顶点的路径为: ";
    searchPath(prev, 1, n);
}

Java普通版本

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
  
public class Dijkstra {
    public static class PointInfo{
        public int point;
        public int prev_point;
        public int dist;
        public PointInfo(int p,int pp,int d){
            point=p;
            prev_point=pp;
            dist=d;
        }
    }
    public static void doit_more_abstract(int[][]array){
        int n=array[0].length;
        Set<PointInfo> knownSet=new HashSet<PointInfo>();
        Set<PointInfo> unknownSet=new HashSet<PointInfo>();
        PointInfo source=new PointInfo(0,-1,0);
        knownSet.add(source);
        for(int p=1;p<n;p++){
            unknownSet.add(new PointInfo(p,-1,Integer.MAX_VALUE));
        }
          
        PointInfo nearest=source;
        while(!unknownSet.isEmpty()){
            //update unkown points' dist
            for(PointInfo p:unknownSet){
                if(p.dist>nearest.dist+array[nearest.point][p.point]){
                    p.prev_point=nearest.point;
                    p.dist=nearest.dist+array[nearest.point][p.point];
                }
            }
            //find minimum dist point
            nearest=new PointInfo(-1,-1,Integer.MAX_VALUE);
            for(PointInfo p:unknownSet){
                if(p.dist<nearest.dist){
                    nearest=p;
                }
            }
            //move from unknown to known
            knownSet.add(nearest);
            unknownSet.remove(nearest);
        }
          
        print(knownSet);
    }
    private static PointInfo getPoint(Set<PointInfo> pset,int index){
        for(PointInfo p:pset){
            if(p.point==index){
                return p;
            }
        }
        return null;
    }
      
    private static void print(Set<PointInfo> knownSet){
        for(int i=0;i<knownSet.size();i++){
            int index=i;
            log("node:"+(index+1)+",weight:"+getPoint(knownSet,index).dist);
            while(index>=0){
                log(""+(index+1));
                index=getPoint(knownSet,index).prev_point;
            }
        }
    }
    public static int[][] makeUpGraph(){
        int[][]array={
                {0,         15,         10,         Infinite,   Infinite,   1},
                {15,        0,          19,         33,         1,          Infinite},
                {10,        19,         0,          27,         Infinite,   Infinite},
                {Infinite,  33,         27,         0,          3,          45},
                {Infinite,  1,          Infinite,   3,          0,          1},
                {1,         Infinite,   Infinite,   45,         1,          0}
                  
        };
        return array;
    }
    public static void log(String s){
        System.out.println(s);
    }
    public static void main(String[]args){
        doit_more_abstract(makeUpGraph());
    }
}

Java 函数式实现版本

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Set;
public class Dijkstra {
    public static class PointInfo{
        public int point;
        public int prev_point;
        public int dist;
        public PointInfo(int p,int pp,int d){
            point=p;
            prev_point=pp;
            dist=d;
        }
    }
private static PointInfo getPoint(Set<PointInfo> pset,int index){
        for(PointInfo p:pset){
            if(p.point==index){
                return p;
            }
        }
        return null;
    }
       
    private static void print(Set<PointInfo> knownSet){
        for(int i=0;i<knownSet.size();i++){
            int index=i;
            log("node:"+(index+1)+",weight:"+getPoint(knownSet,index).dist);
            while(index>=0){
                log(""+(index+1));
                index=getPoint(knownSet,index).prev_point;
            }
        }
    }
       
    public static void doit_functional_way(int[][]array){
        int n=array[0].length;
        Set<PointInfo> knownSet=new HashSet<PointInfo>();
        Set<PointInfo> unknownSet=new HashSet<PointInfo>();
        PointInfo source=new PointInfo(0,-1,0);
        knownSet.add(source);
        for(int p=1;p<n;p++){
            unknownSet.add(new PointInfo(p,-1,Integer.MAX_VALUE));
        }
        PointInfo nearest=source;
        Set<PointInfo> finalSet=iterate(knownSet, unknownSet, nearest, array);
        print(finalSet);
    }
       
    private static Set<PointInfo> iterate(Set<PointInfo> knownSet,Set<PointInfo> unknownSet,PointInfo nearest,int[][]array){
        if(unknownSet.isEmpty()){
            return knownSet;
        }
        //update unkown points' dist
        for(PointInfo p:unknownSet){
            if(p.dist>nearest.dist+array[nearest.point][p.point]){
                p.prev_point=nearest.point;
                p.dist=nearest.dist+array[nearest.point][p.point];
            }
        }
        //find minimum dist point
        nearest=new PointInfo(-1,-1,Integer.MAX_VALUE);
        for(PointInfo p:unknownSet){
            if(p.dist<nearest.dist){
                nearest=p;
            }
        }
        //move from unknown to known
        knownSet.add(nearest);
        unknownSet.remove(nearest);
           
        return iterate(knownSet, unknownSet, nearest, array);
    }
           
    public static int[][] makeUpGraph(){
        int[][]array={
                {0,         15,         10,         Infinite,   Infinite,   1},
                {15,        0,          19,         33,         1,          Infinite},
                {10,        19,         0,          27,         Infinite,   Infinite},
                {Infinite,  33,         27,         0,          3,          45},
                {Infinite,  1,          Infinite,   3,          0,          1},
                {1,         Infinite,   Infinite,   45,         1,          0}
                   
        };
        return array;
    }
    public static void main(String[]args){
        doit_functional_way(makeUpGraph());
    }
}

如果你认真分析最短路径算法，会发现它实际包含了三个核心的概念：

    已知最短路径的点集合A（每个点的信息包括：点的名字、路径上前一个点的名字、路径长度）

    未知最短路径的点集合B（每个点的信息包括：点的名字、路径上前一个点的名字prev_point、路径长度distance）

    刚刚从集合B中选出的距离最小的点nearest_point。

执行过程

    初始状态：

        集合A：仅包含源点

        集合B：包含除源点外的所有点

        nearest_point：源点

    迭代的过程是

        根据nearest_point，更新集合B中每个点的prev_point、distance

        从集合B中选出distance最小的点，作为新的nearest_point

        将nearest_point从集合B移动到集合A中

    结束条件：当集合B为空时，算法结束

个人认为，除了代码运行速度，比较C、Java、Java函数式三个版本implementation的最重要标准是：是否能够直接有力的体现出以上三个核心概念（集合A、集合B、nearest_point）和执行过程。大家如果有耐心读完三个版本的代码，会发现Java两个在这一点上明显比C版本提上了一个层次。

Java普通版本和Java函数式版本的差别在于While循环和iterate递归函数，iterate递归函数更加直观了表现出了“状态变换”。实际上，整个迭代过程就是前一个状态(集合A，集合B，nearest_point)=>后一个状态（集合A、集合B、nearest_point）的变换。

很多函数式语言的拥护者都说：函数式语言的优点是无副作用。我觉得这完全是人与亦云的胡扯。恰恰相反，在使用函数式语言写代码时，它带给我最大的障碍就是无法使用副作用。目前在我眼中，它的最美之处是function as first class object。其次则是对抽象概念和状态变换过程的优雅表达方式。

（我本来用Haskell作为函数式版本的代码示例，但考虑到很多同学大概对这种语言不熟悉，于是使用Java，大家可以看到，即使在imperative语言的环境中，依然可以运用函数式语言的思维方式写出优雅的代码。）