在Java中计算Levenshtein莱文斯坦（相似度）编辑距离

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量764 收藏
点赞数
文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allway2/article/details/127889054
版权

在本教程中，我们将研究 Levenshtein 距离算法，该算法也称为编辑距离算法，用于比较单词的相似性。

什么是列文施泰因距离

Levenshtein距离算法由俄罗斯科学家Vladimir Levenshtein创建。

Levenshtein 距离算法通过计算将一个字符串转换为另一个字符串所需的最小更改/替换次数来比较单词的相似性。这些更改包括：

  • 插入字符
  • 删除字符
  • 字符替换

该算法用于不同的应用或作为以下基础：

  • 拼写检查
  • 语音识别
  • 基因匹配
  • 抄袭检测

列文施泰因距离如何工作

该算法使用暴力技术将源字符串转换为目标字符串。它查看所有排列，以找到执行转换所需的最小更改数。列文施泰因距离算法也称为编辑距离算法。

例如，考虑源词狗和目标词闪避。这两个单词之间的编辑距离是 2，因为狗可以通过在 g 之前插入 d 和之后插入 e 来转换为闪避。

Levenshtein 距离算法还可以为每种类型的编辑分配不同的成本。例如，插入和删除的成本可能为 2，替换成本可能较低，成本为 1。

列文施泰因距离和动态规划

在本教程中，我们将遵循动态编程方法来实现 Levenshtein 距离算法。为了说明这种方法，我们将使用如下所示的矩阵。

上面的矩阵使用行和列来表示源单词 dog，而目标单词 dashge。矩阵将用于计算编辑距离。矩阵的行表示要转换的源单词，其条目是插入每个字符的成本。此外，矩阵中的列用于要转换的目标单词，条目是删除的成本。

  • 我们使用上面的矩阵来测量源词和目标词中字符之间的距离。单元格（行，列）是给定列索引处的行字符和列字符之间的距离。
  • 矩阵将从左上角填充到右下角。
  • 水平或垂直的每个移动都表示插入或删除。
  • 源词和目标词之间的列文施泰因距离结果将显示在右下角。

为了计算每个单元格中的值，我们将使用一个公式，例如：

1
 
minCost(value of left diagonal + substitution cost, value above + deletion cost, left value + insertion cost)

我们将使用以下值作为编辑成本。

1
2
3
 
insertion: 1
deletion: 1
substitution: 1

此外，在上面的公式中，我们将始终将插入和删除的成本设置为 1，并且如果索引 （row：col） 处的字符不同，我们将仅使用替换值 1。

让我们看一个计算第一个单元格的示例。对于此单元格，位置值将为：

1
2
3
 
left diagonal: 0
value above: 1
left value:  1

编辑成本将为：

1
2
3
 
substitution: 0 – characters are the same
insertion: 1 – 1 is a constant value
deletion: 1 – 1 is a constant value

所以：

1
 
minCost(0 + 0, 1 + 1, 1 + 1) → min(0, 2, 2) = 0

让我们继续看单元格 （1，2）。对于此单元格，值将为：

1
 
min(1 + 1, 2 + 1, 0 + 1) → min(2, 3, 1) = 1

我们将继续对其余细胞进行处理。计算完这些值后，我们得到了如下所示的矩阵。

在上面的矩阵中，右下角的值是列文施泰因距离计算的结果。在这种情况下，单词 dog 和 dakge 之间的最小编辑距离为 2。

在分析上述算法时，我们可以看到该算法以二次复杂度 O（MN） 执行，因为将源 M 中的每个字符与目标 N 中的每个字符进行比较以生成完全填充的矩阵。

列文施泰因距离实现

让我们编写一些代码来实现上述算法。

首先，我们将允许可配置编辑的成本：

1
2
3
4
5
6
7
8
9
 
public LevenshteinDistance(int insertionCost, int deletionCost, int substitutionCost) {
    AssertUtils.gte(insertionCost, 0, "Insertion cost must be greater than or equal to 0");
    AssertUtils.gte(deletionCost, 0, "Deletion cost must be greater than or equal to 0");
    AssertUtils.gte(substitutionCost, 0, "Substitution cost must be greater than or equal to 0");

    this.insertionCost = insertionCost;
    this.deletionCost = deletionCost;
    this.substitutionCost = substitutionCost;
}

接下来我们将编写一些代码来计算距离。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public int calculateDistance(CharSequence source, CharSequence target) {
    AssertUtils.notNull(source, "Source cannot be null");
    AssertUtils.notNull(target, "Target cannot be null");

    int sourceLength = source.length();
    int targetLength = target.length();

    int[][] matrix = new int[sourceLength + 1][targetLength + 1];
    matrix[0][0] = 0;

    for (int row = 1; row <= sourceLength; ++row) {
        matrix[row][0] = row;
    }

    for (int col = 1; col <= targetLength; ++col) {
        matrix[0][col] = col;
    }

    for (int row = 1; row <= sourceLength; ++row) {
        for (int col = 1; col <= targetLength; ++col) {
            matrix[row][col] = calcMinCost(source, target, matrix, row, col);
        }
    }

    return matrix[sourceLength][targetLength];
}

我们现在将解释上面列出的代码。在上面的代码中，我们首先使用源和目标长度初始化矩阵：

1
 
int[][] matrix = new int[sourceLength + 1][targetLength + 1];

我们还将矩阵行和列大小设置为比源和目标字长多 1。这样我们就可以通过添加矩阵第一行和第一列的默认值来填充空矩阵。

1
2
3
4
5
6
7
 
for (int row = 1; row <= sourceLength; ++row) {
    matrix[row][0] = row;
}

for (int col = 1; col <= targetLength; ++col) {
    matrix[0][col] = col;
}

上面的代码填充矩阵第一行和第一列的默认值。矩阵完全初始化后，下一步是计算矩阵中每个单元格的值。

1
2
3
4
5
 
for (int row = 1; row <= sourceLength; ++row) {
    for (int col = 1; col <= targetLength; ++col) {
        matrix[row][col] = calcMinCost(source, target, matrix, row, col);
    }
}

上面，我们遍历矩阵的每个单元格，计算其成本。完成此步骤后，可以在矩阵的最后一个单元格中找到最小距离：

1
 
return matrix[sourceLength][targetLength];

现在，让我们看看如何计算每个单元的最小成本。

1
2
3
4
5
6
7
8
 
private int calcMinCost(CharSequence source, CharSequence target,
                        int[][] matrix, int row, int col) {
    return Math.min(
            calcSubstitutionCost(source, target, matrix, row, col), Math.min(
                    calcDeletionCost(matrix, row, col),
                    calcInsertionCost(matrix, row, col))
    );
}

该方法查找单元格编辑的最小成本。它计算替换、插入和删除成本。此方法使用该方法返回计算成本的最小值。calcMinCostMath.min

完整的代码清单如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
public class LevenshteinDistance {
    private final int insertionCost;
    private final int deletionCost;
    private final int substitutionCost;

    public LevenshteinDistance() {
        this(1, 1, 1);
    }

    public LevenshteinDistance(int insertionCost, int deletionCost, int substitutionCost) {
        AssertUtils.gte(insertionCost, 0, "Insertion cost must be greater than or equal to 0");
        AssertUtils.gte(deletionCost, 0, "Deletion cost must be greater than or equal to 0");
        AssertUtils.gte(substitutionCost, 0, "Substitution cost must be greater than or equal to 0");

        this.insertionCost = insertionCost;
        this.deletionCost = deletionCost;
        this.substitutionCost = substitutionCost;
    }

    public int calculateDistance(CharSequence source, CharSequence target) {
        AssertUtils.notNull(source, "Source cannot be null");
        AssertUtils.notNull(target, "Target cannot be null");

        int sourceLength = source.length();
        int targetLength = target.length();

        int[][] matrix = new int[sourceLength + 1][targetLength + 1];
        matrix[0][0] = 0;

        for (int row = 1; row <= sourceLength; ++row) {
            matrix[row][0] = row;
        }

        for (int col = 1; col <= targetLength; ++col) {
            matrix[0][col] = col;
        }

        for (int row = 1; row <= sourceLength; ++row) {
            for (int col = 1; col <= targetLength; ++col) {
                matrix[row][col] = calcMinCost(source, target, matrix, row, col);
            }
        }

        return matrix[sourceLength][targetLength];
    }

    private int calcMinCost(CharSequence source, CharSequence target,
                            int[][] matrix, int row, int col) {
        return Math.min(
                calcSubstitutionCost(source, target, matrix, row, col), Math.min(
                        calcDeletionCost(matrix, row, col),
                        calcInsertionCost(matrix, row, col))
        );
    }

    private int calcInsertionCost(int[][] matrix, int row, int col) {
        return matrix[row][col - 1] + insertionCost;
    }

    private int calcDeletionCost(int[][] matrix, int row, int col) {
        return matrix[row - 1][col] + deletionCost;
    }

    private int calcSubstitutionCost(CharSequence source, CharSequence target,
                                     int[][] matrix, int row, int col) {
        int cost = 0;
        if (source.charAt(row - 1) != target.charAt(col - 1)) {
            cost = substitutionCost;
        }
        return matrix[row - 1][col - 1] + cost;
    }
}

最后，我们将展示用于验证实现的测试：

1
2
3
4
5
6
 
@Test
public void calculateDistance() {
    LevenshteinDistance calculator = new LevenshteinDistance(1,1,1);
    final int result = calculator.calculateDistance("dog", "dodge");
    assertEquals(2,result);
}

结论

在本教程中，我们研究了 levenshtein 距离算法及其一些应用。我们还研究了使用动态规划实现它的一种方法。我们实现了一种以二次复杂度O（MN）执行的算法。因此，可以使用不同的技术来提高该算法的性能。就目前而言，该算法在相对于 O（MN） 的时间内执行，因此，如果不进行一些调整，它可能不会表现出生产用例所需的性能，例如高效的拼写检查器。

allway2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何用python计算levenshteindistance_Levenshtein计算相似度距离
weixin_29370183的博客
02-05 424
使用Levenshtein计算相似度距离，装下模块，调用下函数就好。拿idf还得自己去算权重，而且不一定准确度高，一般做idf还得做词性归一化，把动词形容词什么全部转成名词，很麻烦。Levenshtein.distance(str1,str2)计算编辑距离(也称Levenshtein距离)。是描述由一个字串转化成另一个字串最少的操作次数，在其中的操作包括插入、删除、替换。如例如将eeba转变成ab...
编辑距离算法【莱文斯坦距离、Levenshtein 算法】
xiong_min的博客
05-15 1282
文章目录算法概述：应用与其他编辑距离度量的关系问题定义：解析：例题：参考链接： 算法概述： 在信息论和计算机科学中，莱文斯坦距离是一种两个字符串序列的距离度量。形式化地说，两个单词的莱文斯坦距离是一个单词变成另一个单词要求的最少单个字符编辑数量（如：删除、插入和替换）。莱文斯坦距离也被称做编辑距离，尽管它只是编辑距离的一种，与成对字符串比对紧密相关。一般来说，编辑距离越小，两个串的相似度越大。 ...
如何在Java中计算Levenshtein莱文斯坦（相似度）编辑距离 ？
allway2的博客
11-17 910
这个问题有很多重叠的子问题，但如果我们知道子问题的解决方案，我们就可以很容易地找到原始问题的答案。例如，用键盘上附近的字符替换的成本更低，否则成本更高。我们可以看到，第 #3 节中每个选项的第二步主要是相同的编辑距离问题，但在原始字符串的子。我们还必须为递归算法定义基本情况，在我们的例子中，当一个或两个。来优化朴素实现，即将子问题的结果存储在数组中并重用缓存的结果。在分析递归调用时，我们观察到子问题的参数是原始字符串的后缀。在问题的某些子类中，与每种编辑类型相关的成本可能不同。
如何在Java中使用Levenshtein距离实现字符串相似度匹配
一勺菠萝丶的博客
06-27 550
Levenshtein距离是由俄罗斯科学家Vladimir Levenshtein在1965年提出的，用以量化两个字符串之间的差异。这种度量方式计算将一个字符串转换成另一个字符串所需要的最少编辑操作次数，包括插入、删除和替换字符。通过这个例子，我们可以看到Levenshtein距离是如何帮助我们在实际应用中匹配用户问题的。这种方法不仅适用于问答系统，还可以用于任何需要衡量文本相似度的场景，如搜索引擎优化、数据清洗等。
Levenshtein莱文斯坦计算相似度距离
猪逻辑公园
11-13 4554
https://github.com/ztane/python-Levenshtein/ https://pypi.org/project/python-Levenshtein/ Levenshtein.distance(str1,str2) 1.百度百科介绍： Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。 许可的编辑操作包...
计算字符串相似度之莱文斯坦距离
MicroAnswer的博客
05-21 867
详细介绍了基于莱文斯坦距离的字符串相似度计算方法和其原理。是一篇小白也能看懂的介绍。
python实现Levenshtein 距离相似度计算
旅途
03-26 1345
Levenshtein 距离 1、概念 Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。（即：插入、删除、替换）。 相似度 ,其中Distance指编辑距离，max是指两个字符串的长度总和。 2、python实现 安装包： ...
字符串之间相似度的计算：莱文斯坦算法
coder_afly的博客
11-14 1873
       毕业后的第一份工作：MDM主数据的开发。服务的对象是某国企巨头，员工就有几万人。该公司呢，产品有很多，客户也特别多。每天的增量巨大，而负责录入的工作人员也有很多，由于每个人语言表达习惯不同，文化程度不同，工作态度不同等等，所以申请出来的数据也是五花八门。前期的MDM系统功能不够完善，为防止申请的信息重复，对于客户和产品信息的唯一性校验仅仅是对名称进行校验。在学校做过一些课程设计，对名...
Java实现莱文斯坦（相似度）算法，用于试题相似度，字符串相似度等场景
一火的专栏
01-13 1452
一、莱文斯坦（相似度）算法 使用Levenshtein(莱文斯坦)编辑距离来实现相似度算法 所谓Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，操作包括一切你使用的手段将一个字符串转换成另一个字符串，比如插入一个字符、删除一个字符..等等；操作次数越少，说明两个字符串距离Levenshtein Distance越小，表示两个字符串越相似。...
相似度算法--莱文斯坦距离加入同义词逻辑
黄智霖的博客
02-01 5130
在问题检索中，依赖文本相似度给用户做推荐问题，假设1.0分为满分，那么： 1.0分表示完全匹配：可以将问题准确推送给用户 0.8分表示高度相似：可以将问题推荐给用户 0.6分表示低度相似：...... 根据这样的规则对用户的检索做出回应。其实Lucene基于TF-IDF改造的相关度排序算法也有分值，但是和业务所需要的相似度不贴合，所以其得分只作为第一步结果筛选依据。关于Lucene打分公式可以看看这篇文章。 二、莱文斯坦距离 文本相似度算法有很多，这里选择的是编辑距离算法-莱文斯坦距离(Le
C#，字符串相似度的莱文斯坦距离（Levenshtein Distance）算法与源代码
03-24
莱文斯坦距离，是编辑距离（Edit Distance）的一种。 编辑距离一般是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。允许的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。 比如...
Python文本相似性计算之编辑距离详解
09-21
在计算中文字符串的编辑距离时，需要注意编码问题。默认情况下，Python的字符串是以UTF-8编码存储的，一个中文字符可能由多个字节表示。因此，当比较中文字符串时，可能得到不准确的结果。解决这个问题的方法是将...
ld.rar_LD算法_edit distance_最小编辑距离_编辑距离
09-21
在计算莱文斯坦距离时，动态规划通常涉及到一个二维矩阵，其中每个单元格的值表示对应位置的两个字符之间需要多少次编辑操作才能转换到对方。 标签中的“ld算法”、“edit_distance”、“最小编辑距离”和“编辑...
文本相似度计算
10-12
在文本相似度计算中，Levenshtein距离通常被用作基础，通过一定的调整和优化来适应更复杂的文本场景。例如，可以对每个字符赋予不同的权重，使得某些字符的改动比其他字符的改动更重要。此外，为了提高效率，还可以...
Levenshtein_mysql:mysql 自定义函数。用来计算字符A转换成字符串B所花费的代价，数值越小，代价越低。（换句话来说，就计算两个字符串的相似度，值越小相似度越高）
05-14
该实现采用了编辑距离算法，详见：###2、使用方法：使用源代码的话，从第1步开始。如果是直接使用二进制发布包的话，直接从第4步开始即可。1）下载本代码2）安装mysql开发包。 mysql主分支文件名类型：...
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 460
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 568
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
使用最小编辑距离计算字符串相似度
"最小编辑距离是衡量两个字符串相似度的一种方法，常用于拼写纠正、生物信息学中的序列比对、机器翻译、信息提取和...通过动态规划算法，我们可以高效地计算出这个距离，从而在多种应用场景中实现字符串的相似度比较。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值