java levenshtein算法_Levenshtein Distance算法（java实现）

所谓Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，操作包括一切你使用的手段将一个字符串转换成另一个字符串，比如插入一个字符、删除一个字符..等等；操作次数越少，说明两个字符串距离Levenshtein Distance越小，表示两个字符串越想似。

应用最广泛的的当然就是DNA序列比对了。

此处算法思想用一个“代价表”表示(我这里这么称呼，因为比对过程中产生的代价总和就是字符串的距离)，比如有两个字符串s1=“ABCDEFGZ”,s2="ABFDFEGXY"；则代价表如下：(代价表实现思想：若比较过程中两个字符相同，则直接取左上角代价，若不同，则取左上角、左、上三方代价最小值再加1.)

代价表

A

B

C

D

E

F

G

Z

0

1

2

3

4

5

6

7

8

A

1

0

1

2

3

4

5

6

7

B

2

1

0

1

2

3

4

5

6

F

3

2

1

1

2

3

3

4

5

D

4

3

2

2

1

2

3

4

5

F

5

4

3

3

2

2

2

3

4

E

6

5

4

4

3

2

3

3

4

G

7

6

5

5

4

3

4

3

4

X

8

7

6

6

5

4

5

4

4

Y

9

8

7

7

6

5

6

5

5

由上述表可得：

s1=“ABCDEFGZ”与s2="ABFDFEGXY"的距离为5

程序实现如下：

package com.wxhi.main;

/**

* Levenshtein Distance算法

* @author wxshi

*

*/

public class Levenshtein {

/**

* @param s1

* @param s2

* @return Levenshtein Distance

*/

public double getStringDistance(String s1, String s2) {

double distance[][];// 定义距离表

int s1_len = s1.length();

int s2_len = s2.length();

if (s1_len == 0) {

return s2_len;

}

if (s2_len == 0) {

return s1_len;

}

distance = new double[s1_len + 1][s2_len + 1];

// 二维数组第一行和第一列放置自然数

for (int i = 0; i <= s1_len; i++) {

distance[i][0] = i;

}

for (int j = 0; j <= s2_len; j++) {

distance[0][j] = j;

}

// 比较，若行列相同，则代价为0，否则代价为1；

for (int i = 1; i <= s1_len; i++) {

char s1_i = s1.charAt(i - 1);

// 逐一比较

for (int j = 1; j <= s2_len; j++) {

char s2_j = s2.charAt(j - 1);

// 若相等，则代价取0；直接取左上方值

if (s1_i == s2_j) {

distance[i][j] = distance[i - 1][j - 1];

} else {

// 否则代价取1，取左上角、左、上 最小值 + 代价(代价之和便是最终距离)

distance[i][j] = getMin(distance[i - 1][j], distance[i][j - 1], distance[i - 1][j - 1]) + 1;

}

}

}

// 取二位数组最后一位便是两个字符串之间的距离

return distance[s1_len][s2_len];

}

// 求最小值

private double getMin(double a, double b, double c) {

double min = a;

if (b < min) {

min = b;

}

if (c < min) {

min = c;

}

return min;

}

}