Java算法之Levenshtein Distance（编辑距离）算法

有关这个算法的介绍在这里：编辑距离算法以及字符串相似度算法

这里重点是matrix的算法，下面是它的计算过程。

首先初始化matrix：

要注意这三个值：matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + t。这里面的t指的是s1[i] == s2[j]两相比较的结果，如果相同就记为0，如果不同就记为1。中间的位置如何取值取决于上面三个值哪个最小。当i=1并且j=1的时候这几个值分别是：0+t, 1+1, 1+1。其它的，以此类推。

还是来写下详细步骤吧：

1. 当i = 1，j = 1的时候，s1[1] = s2[1]，此时t = 0，matrix[0][1] + 1 = 1 + 1 = 2，matrix[1][0] + 1 = 1 + 1 = 2，matrix[0][0] + 0 = 0 + 0 = 0；而matrix[1][1]的值由它们三个值中的最小者来确定，所以matrix[1][1] = 0；

2. 以此类推，直到i = 5, j = 5。

最终的结果：

由此得出，相似度为0.8，matrix的结果为1。

以下是代码：

public class LevenshteinDistanceAlgo {

    public static void main(String[] args) {
        String s1 = "china";
        String s2 = "chino";
        System.out.println("matrix: " + matrix(s1, s2));
        System.out.println("similar: " + similarCalc(s1, s2));
    }
    
    private static int min(int one, int two, int three) {
        int min = one;
        if (two < min) min = two;
        if (three < min) min = three;
        return min;
    }
    
    public static int matrix(String s1, String s2) {
        int matrix[][];
        int n = s1.length();
        int m = s2.length();
        int i;
        int j;
        char c1;
        char c2;
        int temp;
        if (n == 0) return m;
        if (m == 0) return n;
        
        matrix = new int[n + 1][m + 1];
        for (i = 0; i <= n; i++) {
            matrix[i][0] = i;
        }
        
        for (j = 0; j <= m; j++) {
            matrix[0][j] = j;
        }
        
        for (i = 1; i <= n; i++) {
            c1 = s1.charAt(i - 1);
            
            for (j = 1; j <= m; j++) {
                c2 = s2.charAt(j - 1);
                if (c1 == c2) temp = 0;
                else temp = 1;
                
                matrix[i][j] = min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + temp);
            }
        }
        
        return matrix[n][m];
    }
    
    public static double similarCalc(String s1, String s2) {
        int value = matrix(s1, s2);
        return 1 - (double) value / Math.max(s1.length(), s2.length());
    }
}