编辑距离（Levenshtein Distance）** 的生物学应用知识，在生物信息学中用于衡量 DNA 序列（可抽象为字符串）的相似性，辅助研究物种进化关系

原创于 2025-06-18 23:45:00 发布 · 958 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#代理模式

Structured(design engineering) 同时被 3 个专栏收录

486 篇文章

订阅专栏

App(Application Java Kotlin)

329 篇文章

订阅专栏

Data(Structures Algorithms)

121 篇文章

订阅专栏

这是关于编辑距离（Levenshtein Distance） 的生物学应用知识，在生物信息学中用于衡量 DNA 序列（可抽象为字符串）的相似性，辅助研究物种进化关系。核心是通过插入、删除、替换字符的最小操作次数，用动态规划（二维数组 d 递推）求解，完整递推公式通常为（设 str1[i] 、str2[j] 为对应字符）：

若 i = 0 且 j = 0，d[i][j] = 0
若 i = 0 且 j > 0，d[i][j] = j（插入 j 次）
若 j = 0 且 i > 0，d[i][j] = i（删除 i 次）
若 i > 0 且 j > 0，d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (str1[i - 1] != str2[j - 1] ? 1 : 0)) ，分别对应删除、插入、替换操作的最优解。
以下是使用 Python 实现编辑距离（Levenshtein Distance）计算的代码示例，基于动态规划思路：

def edit_distance(str1, str2):
    len1, len2 = len(str1), len(str2)
    # 创建二维 dp 数组，dp[i][j] 表示 str1 前 i 个字符与 str2 前 j 个字符的编辑距离
    dp = [[0] * (len2 + 1) for _ in range(len1 + 1)]
    
    # 初始化边界：str1 为空时，编辑距离为插入 j 个字符（j 为 str2 长度）
    for j in range(len2 + 1):
        dp[0][j] = j
    # 初始化边界：str2 为空时，编辑距离为删除 i 个字符（i 为 str1 长度）
    for i in range(len1 + 1):
        dp[i][0] = i
    
    # 动态规划填表
    for i in range(1, len1 + 1):
        for j in range(1, len2 + 1):
            # 若当前字符相同，无需额外操作，距离等于 dp[i-1][j-1]
            if str1[i - 1] == str2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                # 否则取“删除、插入、替换”操作的最小值 +1
                dp[i][j] = 1 + min(dp[i - 1][j],    # 删除 str1 第 i 个字符
                                   dp[i][j - 1],    # 插入字符到 str1 对应位置
                                   dp[i - 1][j - 1])# 替换 str1 第 i 个字符为 str2 第 j 个字符
    return dp[len1][len2]

# 示例调用
str1 = "kitten"
str2 = "sitting"
print(edit_distance(str1, str2))

代码说明：

初始化 dp 数组：dp 是一个 (len1+1) * (len2+1) 的二维数组，dp[i][j] 存储 str1 前 i 个字符与 str2 前 j 个字符的编辑距离。
边界处理：当其中一个字符串为空时，编辑距离等于另一个字符串的长度（全插入/全删除操作）。
状态转移：遍历填充 dp 数组，根据当前字符是否相等，选择“删除、插入、替换”中的最小操作数更新 dp[i][j] 。
返回结果：最终 dp[len1][len2] 即为两个完整字符串的编辑距离。

若用 Java 实现，逻辑类似，示例代码：

public class EditDistance {
    public static int editDistance(String str1, String str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        int[][] dp = new int[len1 + 1][len2 + 1];

        for (int j = 0; j <= len2; j++) {
            dp[0][j] = j;
        }
        for (int i = 0; i <= len1; i++) {
            dp[i][0] = i;
        }

        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = 1 + Math.min(
                        Math.min(dp[i - 1][j], dp[i][j - 1]), 
                        dp[i - 1][j - 1]
                    );
                }
            }
        }
        return dp[len1][len2];
    }

    public static void main(String[] args) {
        String str1 = "kitten";
        String str2 = "sitting";
        System.out.println(editDistance(str1, str2));
    }
}

两种语言核心逻辑一致，都是通过动态规划逐步推导编辑距离，可根据需求（如生物信息学中 DNA 序列对比场景）替换输入字符串使用。
编辑距离在生物学中，尤其是在分子生物学和进化生物学领域，有着广泛的应用。以下是编辑距离在生物学中的具体应用：

DNA序列比对：
- 编辑距离可以用来比较两个DNA序列之间的相似性。通过计算两个序列之间的编辑距离，可以了解它们在进化过程中可能发生的突变数量，从而推断它们的亲缘关系。
基因组比较：
- 在基因组学中编辑，距离用于比较不同物种的基因组，帮助科学家理解基因组的进化历史和物种分化。
蛋白质序列分析：
- 类似于DNA序列，编辑距离也可以用来比较蛋白质序列。这有助于理解蛋白质的功能、结构和进化关系。
系统发育树构建：
- 编辑距离是构建系统发育树（phylogenetic trees）的一种方法。通过计算不同物种之间的编辑距离，可以构建反映它们进化关系的树状图。
基因突变研究：
- 在癌症研究中，编辑距离可以用来分析肿瘤细胞的基因组与细胞正常基因组之间的差异，帮助识别导致癌症的突变。
遗传病研究：
- 编辑距离可以帮助识别遗传病相关的基因突变，通过比较患者和健康个体的基因序列，找出可能导致疾病的突变。
生物信息学工具：
- 许多生物信息学工具和算法使用编辑距离来改进序列比对和分析，提高数据处理的准确性和效率。
进化速率估计：
- 通过比较不同时间点的序列，编辑距离可以帮助估计物种或基因的进化速率。

编辑距离是一种简单而强大的工具，它在生物学研究中提供了一种量化序列差异的方法，有助于理解生物多样性和进化过程。
以下是添加详细注释的 Python 实现：

def edit_distance(str1, str2):
    """
    计算两个字符串之间的编辑距离（Levenshtein Distance）
    返回将 str1 转换为 str2 所需的最少插入、删除、替换操作次数
    """
    len1, len2 = len(str1), len(str2)
    
    # 创建二维动态规划数组 dp[i][j]
    # 表示 str1 前 i 个字符（索引 0~i-1）与 str2 前 j 个字符（索引 0~j-1）的编辑距离
    dp = [[0] * (len2 + 1) for _ in range(len1 + 1)]
    
    # 初始化边界条件：当 str1 为空字符串时
    # 编辑距离等于 str2 的长度（需插入 j 个字符）
    for j in range(len2 + 1):
        dp[0][j] = j
    
    # 初始化边界条件：当 str2 为空字符串时
    # 编辑距离等于 str1 的长度（需删除 i 个字符）
    for i in range(len1 + 1):
        dp[i][0] = i
    
    # 填充动态规划表格
    # 遍历 str1 和 str2 的每个字符
    for i in range(1, len1 + 1):
        for j in range(1, len2 + 1):
            # 若当前字符相同，无需额外操作
            # 编辑距离等于前一个子问题的距离
            if str1[i - 1] == str2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                # 否则，选择以下三种操作中的最小代价 +1
                # 1. 删除操作：dp[i-1][j] + 1
                # 2. 插入操作：dp[i][j-1] + 1
                # 3. 替换操作：dp[i-1][j-1] + 1
                dp[i][j] = 1 + min(
                    dp[i - 1][j],      # 删除 str1 当前字符
                    dp[i][j - 1],      # 插入 str2 当前字符
                    dp[i - 1][j - 1]   # 替换 str1 当前字符为 str2 当前字符
                )
    
    # 返回最终结果：两个完整字符串的编辑距离
    return dp[len1][len2]

# 示例调用
str1 = "kitten"
str2 = "sitting"
print(f"从 '{str1}' 到 '{str2}' 的编辑距离是: {edit_distance(str1, str2)}")

关键步骤解释：

动态规划数组 dp：
- dp[i][j] 表示 str1 的前 i 个字符和 str2 的前 j 个字符之间的编辑距离
- 维度为 (len1+1) x (len2+1)，包含空字符串情况
边界条件：
- dp[0][j] = j：空字符串 → 长度为 j 的字符串需要 j 次插入
- dp[i][0] = i：长度为 i 的字符串 → 空字符串需要 i 次删除

状态转移方程：

dp[i][j] = min(
    dp[i-1][j] + 1,    # 删除操作
    dp[i][j-1] + 1,    # 插入操作
    dp[i-1][j-1] + cost  # 替换操作（cost=0 当字符相同时）
)

时间与空间复杂度：
- 时间复杂度：O(mn)，m 和 n 分别为两字符串长度
- 空间复杂度：O(mn)，可优化至 O(n)（使用滚动数组）

示例计算过程：

以 str1="kitten" 和 str2="sitting" 为例：

  |   | s | i | t | t | i | n | g |
--+---+---+---+---+---+---+---+---+
  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |  # 空字符串 → sitting
k | 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
i | 2 | 2 | 1 | 2 | 3 | 4 | 5 | 6 |
t | 3 | 3 | 2 | 1 | 2 | 3 | 4 | 5 |
t | 4 | 4 | 3 | 2 | 1 | 2 | 3 | 4 |
e | 5 | 5 | 4 | 3 | 2 | 2 | 3 | 4 |
n | 6 | 6 | 5 | 4 | 3 | 3 | 2 | 3 |

最终 dp[6][7]=3，表示将 “kitten” 转换为 “sitting” 需要 3 次操作。
在这里插入图片描述