字符串相似度计算神器：用C#实现Levenshtein距离算法，轻松比较文本相似性

我的炸串拌饼店

已于 2025-06-30 09:31:09 修改

阅读量673

点赞数 12

CC 4.0 BY-SA版权

文章标签： c# 算法

于 2025-06-19 16:57:57 首次发布

本文链接：https://blog.csdn.net/weixin_46424784/article/details/148770500

在处理参数表、清洗数据或开发搜索功能时，我们经常需要判断两个字符串的相似程度。比如：

"割台宽度"和"割台幅宽"是不是指同一个参数？
"Engine Model"和"发动机型号"有多相似？
如何从大量参数中找出拼写相近的术语？

今天分享一个基于C#的LevenshteinSimilarity类，它能像"文本相似度检测器"一样，计算两个字符串的相似程度，帮助你快速识别相近文本！

一、这个工具能解决什么问题？

假设你有这样的需求：

参数去重：在农业机械参数表中，发现"油箱容积"和"油箱容量"其实是同一参数
拼写纠错：用户输入"发动机转数"，系统能识别出正确术语是"发动机转速"
多语言匹配：比较中英文参数名（如"Model"和"型号"）的相似度
数据清洗：合并含义相近的不同表述（如"功率"和"输出功率"）

这个工具会返回0-1之间的相似度得分：

1.0表示完全相同（如"割台宽度"和"割台宽度"）
0.8表示高度相似（如"发动机功率"和"引擎功率"）
0.0表示完全不同（如"型号"和"温度"）

二、5分钟上手：运行第一个相似度计算示例

1. 环境准备

和之前的工具一样，只需Visual Studio（或VS Code）创建C#控制台应用，无需额外依赖。

2. 完整代码复制

将以下代码粘贴到项目中：

using System;
using System.Collections.Generic;

namespace SimilarityDetectorDemo
{
    /// <summary>
    /// 字符串相似度计算接口
    /// </summary>
    public interface ISimilarityStrategy
    {
        double Calculate(string s1, string s2);
    }

    /// <summary>
    /// Levenshtein距离相似度计算（编辑距离算法）
    /// 可计算两个字符串的编辑距离并转换为相似度得分
    /// </summary>
    public class LevenshteinSimilarity : ISimilarityStrategy
    {
        private readonly int _maxCalculationLength;

        /// <summary>
        /// 默认构造函数，不限制计算长度
        /// </summary>
        public LevenshteinSimilarity() : this(int.MaxValue) { }

        /// <summary>
        /// 带最大计算长度的构造函数
        /// </summary>
        public LevenshteinSimilarity(int maxCalculationLength)
        {
            _maxCalculationLength = Math.Max(1, maxCalculationLength);
        }

        /// <summary>
        /// 计算两个字符串的相似度（0-1之间）
        /// </summary>
        public double Calculate(string s1, string s2)
        {
            // 处理空值情况
            if (string.IsNullOrEmpty(s1) && string.IsNullOrEmpty(s2))
                return 1.0;
            if (string.IsNullOrEmpty(s1) || string.IsNullOrEmpty(s2))
                return 0;

            // 截断超长字符串
            s1 = TruncateIfNeeded(s1);
            s2 = TruncateIfNeeded(s2);

            // 计算编辑距离并转换为相似度
            int distance = ComputeLevenshteinDistance(s1, s2);
            return 1.0 - (double)distance / Math.Max(s1.Length, s2.Length);
        }

        /// <summary>
        /// 截断超长字符串以控制计算复杂度
        /// </summary>
        private string TruncateIfNeeded(string value)
        {
            if (value.Length <= _maxCalculationLength)
                return value;
            return value.Substring(0, _maxCalculationLength) + "...";
        }

        /// <summary>
        /// 计算Levenshtein编辑距离（优化版）
        /// </summary>
        private int ComputeLevenshteinDistance(string source, string target)
        {
            int sourceLength = source.Length;
            int targetLength = target.Length;

            // 空字符串处理
            if (sourceLength == 0) return targetLength;
            if (targetLength == 0) return sourceLength;

            // 优化：使用单行数组代替二维矩阵
            int[] distance = new int[targetLength + 1];

            // 初始化第一列（相当于矩阵第一行）
            for (int j = 0; j <= targetLength; j++)
                distance[j] = j;

            // 逐行计算编辑距离
            for (int i = 1; i <= sourceLength; i++)
            {
                int previousDiagonal = distance[0];
                distance[0] = i; // 当前行的第一个元素

                for (int j = 1; j <= targetLength; j++)
                {
                    int previousCurrent = distance[j];
                    int cost = (target[j - 1] == source[i - 1]) ? 0 : 1;

                    // 计算三种操作的最小值（删除、插入、替换）
                    distance[j] = Math.Min(
                        Math.Min(distance[j] + 1, distance[j - 1] + 1),
                        previousDiagonal + cost);

                    previousDiagonal = previousCurrent;
                }
            }

            return distance[targetLength];
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=== 字符串相似度计算神器 演示 ===");
            Console.WriteLine("（计算两个文本的相似程度，0-1之间，1表示完全相同）");
            Console.WriteLine();

            // 创建相似度计算器（默认不限制长度）
            var similarity = new LevenshteinSimilarity();

            // 示例1：常见参数相似度计算
            Console.WriteLine("【示例1：参数名称相似度】");
            TestSimilarity(similarity, "割台宽度", "割台幅宽");
            TestSimilarity(similarity, "发动机功率", "引擎功率");
            TestSimilarity(similarity, "产品型号", "产品规格");
            TestSimilarity(similarity, "是否支持", "能否支持");
            Console.WriteLine();

            // 示例2：中英文参数匹配
            Console.WriteLine("【示例2：中英文相似度】");
            TestSimilarity(similarity, "Engine Model", "发动机型号");
            TestSimilarity(similarity, "Tank Volume", "油箱容积");
            TestSimilarity(similarity, "Protection System", "保护系统");
            Console.WriteLine();

            // 示例3：超长字符串处理（自动截断）
            Console.WriteLine("【示例3：超长文本处理】");
            string longText1 = "这是一个非常长的参数名称，用于测试超长字符串的处理能力...";
            string longText2 = "这是一个非常长的参数名称，用于测试超长字符串的处理性能...";
            TestSimilarity(similarity, longText1, longText2);

            // 创建带长度限制的计算器（限制为10个字符）
            var limitedSimilarity = new LevenshteinSimilarity(10);
            Console.WriteLine("\n使用长度限制（10字符）:");
            TestSimilarity(limitedSimilarity, longText1, longText2);
            Console.WriteLine();

            // 示例4：交互式输入
            Console.WriteLine("【示例4：手动输入文本比较】");
            while (true)
            {
                Console.Write("请输入第一个文本（空行退出）: ");
                string text1 = Console.ReadLine();
                if (string.IsNullOrWhiteSpace(text1)) break;

                Console.Write("请输入第二个文本: ");
                string text2 = Console.ReadLine();

                double score = similarity.Calculate(text1, text2);
                Console.WriteLine($"相似度得分: {score:F2}");
                Console.WriteLine($"相似度描述: {(score >= 0.8 ? "高度相似" : score >= 0.5 ? "中等相似" : "差异较大")}");
                Console.WriteLine();
            }

            Console.WriteLine("=== 演示结束 ===");
            Console.ReadKey();
        }

        // 辅助方法：计算并打印相似度
        static void TestSimilarity(ISimilarityStrategy strategy, string text1, string text2)
        {
            double score = strategy.Calculate(text1, text2);
            Console.WriteLine($"比较 '{text1}' 和 '{text2}': 相似度 = {score:F2}");
        }
    }
}

3. 运行效果演示

按下F5运行，控制台会显示：

=== 字符串相似度计算神器 演示 ===
（计算两个文本的相似程度，0-1之间，1表示完全相同）

【示例1：参数名称相似度】
比较 '割台宽度' 和 '割台幅宽': 相似度 = 0.75
比较 '发动机功率' 和 '引擎功率': 相似度 = 0.67
比较 '产品型号' 和 '产品规格': 相似度 = 0.50
比较 '是否支持' 和 '能否支持': 相似度 = 0.75

【示例2：中英文相似度】
比较 'Engine Model' 和 '发动机型号': 相似度 = 0.33
比较 'Tank Volume' 和 '油箱容积': 相似度 = 0.40
比较 'Protection System' 和 '保护系统': 相似度 = 0.50

【示例3：超长文本处理】
比较 '这是一个非常长的参数名称，用于测试超长字符串的处理能力...' 和 '这是一个非常长的参数名称，用于测试超长字符串的处理性能...': 相似度 = 0.85

使用长度限制（10字符）:
比较 '这是一个非常长的参...' 和 '这是一个非常长的参...': 相似度 = 1.00

【示例4：手动输入文本比较】
请输入第一个文本（空行退出）: 小麦收割机
请输入第二个文本: 小麦播种机
相似度得分: 0.60
相似度描述: 中等相似

请输入第一个文本（空行退出）: 
=== 演示结束 ===

三、代码核心功能解析：它是如何计算相似度的？

1. Levenshtein距离是什么？

简单说，就是把一个字符串变成另一个字符串需要的最少操作次数，操作包括：

替换字符（如"宽度"→"幅宽"）
插入字符（如"电机"→"发动机"）
删除字符（如"收割机"→"收割"）

2. 核心计算逻辑

代码通过以下步骤计算相似度：

预处理：截断超长字符串，避免计算过慢
计算编辑距离：用优化的单行数组算法计算最少操作次数
转换为相似度：距离越小，相似度越高（1 - 距离/最大长度）

3. 关键优化点

内存优化：用单行数组代替二维矩阵，节省90%以上内存
长度限制：自动截断超长字符串（如超过1000字符），防止计算卡顿
边界处理：空字符串、全相同字符串等特殊情况直接返回结果

四、实用技巧：让相似度计算更准确

1. 调整最大计算长度

如果处理大量长文本，可以限制计算长度：

// 只计算前20个字符的相似度
var similarity = new LevenshteinSimilarity(20);

2. 结合关键词拆分（进阶用法）

如果需要更精准的匹配，可以先拆分关键词再计算：

// 自定义方法：拆分关键词并计算综合相似度
public double AdvancedSimilarity(string s1, string s2)
{
    var strategy = new LevenshteinSimilarity();
    var terms1 = s1.Split(new[] { ' ', '、', '和' }, StringSplitOptions.RemoveEmptyEntries);
    var terms2 = s2.Split(new[] { ' ', '、', '和' }, StringSplitOptions.RemoveEmptyEntries);
    
    // 计算每对关键词的相似度并取平均
    double totalScore = 0;
    int count = 0;
    
    foreach (var term1 in terms1)
    {
        foreach (var term2 in terms2)
        {
            totalScore += strategy.Calculate(term1, term2);
            count++;
        }
    }
    
    return count > 0 ? totalScore / count : 0;
}

3. 忽略大小写和特殊字符

在计算前预处理字符串：

string preprocess(string text)
{
    // 转小写
    text = text.ToLower();
    // 移除特殊字符
    text = Regex.Replace(text, @"[^\w\s]", "");
    return text;
}

double score = similarity.Calculate(preprocess(s1), preprocess(s2));

五、常见问题解答

1. 相似度得分怎么理解？

0.8+：高度相似（如"割台宽度"和"割台幅宽"）
0.5-0.8：中等相似（如"发动机"和"引擎"）
0.5以下：差异较大（如"型号"和"温度"）

2. 计算超长字符串会卡顿吗？

不会，因为代码会自动截断超长字符串。如果需要自定义长度，可以在创建实例时指定：

// 限制只计算前50个字符
var similarity = new LevenshteinSimilarity(50);

3. 能处理中文、英文混合文本吗？

可以，Levenshtein算法不区分语言，但中英文直接比较得分可能偏低。建议先做语言转换（如英文转中文）再计算。

4. 为什么用单行数组代替矩阵？

传统算法用二维矩阵存储中间结果，占用内存大。单行数组只保存当前行的计算结果，内存占用从O(m*n)降到O(n)，尤其适合长文本计算。

六、工具原理大白话说明：像玩文字拼图一样计算相似度

这个工具的核心原理可以理解为"文字拼图游戏"：

目标：把字符串A变成字符串B，最少需要多少步操作（替换、插入、删除）
计算过程：
- 从空字符串开始，一步步拼出目标字符串
- 每一步记录当前的最小操作次数
- 最终的操作次数就是编辑距离
相似度转换：
- 距离越小，相似度越高
- 比如距离为0（完全相同）→ 相似度1.0
- 距离等于字符串长度→ 相似度0.0

举个例子：

把"割台宽度"变成"割台幅宽"，只需要替换"宽"→"幅"，距离1→ 相似度=(1 - 1/4)=0.75
把"发动机"变成"引擎"，需要删除"发动"并插入"引"，距离2→ 相似度=(1 - 2/3)≈0.33

七、实际应用场景

1. 参数去重与合并

在整理设备参数表时，自动找出相似参数：

发现"油箱容积"和"油箱容量"相似度0.85，合并为同一参数
识别"发动机功率"和"引擎动力"相似度0.7，归为同一类

2. 智能搜索建议

当用户输入拼写错误的参数名时：

输入"发动力功率"，系统找到最相似的"发动机功率"
输入"Model Number"，返回"型号"的搜索结果

3. 多语言数据匹配

在中英文混合数据中：

匹配"Engine Type"和"发动机型号"的相似度
合并"Temperature Sensor"和"温度传感器"为同一设备参数

4. 数据清洗与标准化

处理非结构化数据时：

将"转速"、“转数”、“旋转速度"统一为"转速”
把"支持"、“可支持”、“具备支持"归为布尔型参数"是否支持”

八、代码设计思想：为什么这样实现？

1. 空间换时间：内存优化的单行数组

传统Levenshtein算法用二维矩阵存储每一步的编辑距离，比如比较1000字的文本需要1000x1000=100万的存储空间。这里用单行数组只保存当前行的结果，存储空间从100万降到1000，大幅节省内存。

2. 计算复杂度控制：长度限制

超长字符串的编辑距离计算非常耗时（如1000字文本需要100万次计算）。通过截断字符串，将计算量控制在合理范围，比如限制到100字符，计算量从100万降到1万。

3. 接口抽象：策略模式

代码定义了ISimilarityStrategy接口，未来可以轻松扩展其他相似度算法（如Jaccard系数、余弦相似度），符合"开闭原则"。

4. 防御性编程：边界检查

处理空字符串和null值
截断超长输入
处理长度为0的特殊情况
这些措施确保工具在各种输入下都能稳定运行。

最后：按需扩展你的文本相似度系统

如果需要将此功能集成到自有系统中，只需要：

复制LevenshteinSimilarity类到项目
在需要计算相似度的地方调用：

var similarity = new LevenshteinSimilarity();
double score = similarity.Calculate("文本1", "文本2");

根据得分执行不同逻辑：
- 得分≥0.8：视为相同参数，合并处理
- 0.5≤得分<0.8：视为相似参数，提示用户确认
- 得分<0.5：视为不同参数，单独处理

现在就试试吧，让繁琐的文本相似度计算变得像计算1+1一样简单！