C#：编辑距离计算及更新维基百科

最新推荐文章于 2024-04-11 15:27:00 发布
最新推荐文章于 2024-04-11 15:27:00 发布
阅读量1.9k 收藏
点赞数
文章标签： c# distance string actionscript 开发工具 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhqin/article/details/6555920
版权

开发工具：

Visual Studio v2010

.NET Framework 4 Client Profile

维基百科相关主题：

http://en.wikipedia.org/wiki/Levenshtein_distance

http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance（更新）

源代码：

EditDistance.cs

using System;
using System.Collections.Generic;

namespace Splash
{
    /// <summary>
    /// 编辑距离：莱文斯坦距离 Damerau-Levenshtein Distance
    /// </summary>
    public static class SpellHelper
    {
        /// <summary>
        /// 莱文斯坦距离（Levenshtein Distance）
        /// </summary>
        /// <param name="source">源串</param>
        /// <param name="target">目标串</param>
        /// <param name="similarity">输出：相似度，值在0～1</param>
        /// <param name="isCaseSensitive">是否大小写敏感</param>
        /// <returns>源串和目标串之间的编辑距离</returns>
        /// <remarks>http://en.wikipedia.org/wiki/Levenshtein_distance</remarks>
        public static Int32 LevenshteinDistance(String source, String target, out Double similarity, Boolean isCaseSensitive = false)
        {
            if (String.IsNullOrEmpty(source))
            {
                if (String.IsNullOrEmpty(target))
                {
                    similarity = 1;
                    return 0;
                }
                else
                {
                    similarity = 0;
                    return target.Length;
                }
            }
            else if (String.IsNullOrEmpty(target))
            {
                similarity = 0;
                return source.Length;
            }

            String From, To;
            if (isCaseSensitive)
            {   // 大小写敏感
                From = source;
                To = target;
            }
            else
            {   // 大小写无关
                From = source.ToLower();
                To = target.ToLower();
            }

            // 初始化
            Int32 m = From.Length;
            Int32 n = To.Length;
            Int32[,] H = new Int32[m + 1, n + 1];
            for (Int32 i = 0; i <= m; i++) H[i, 0] = i;  // 注意：初始化[0,0]
            for (Int32 j = 1; j <= n; j++) H[0, j] = j;

            // 迭代
            for (Int32 i = 1; i <= m; i++)
            {
                Char SI = From[i - 1];
                for (Int32 j = 1; j <= n; j++)
                {   // 删除（deletion） 插入（insertion） 替换（substitution）
                    if (SI == To[j - 1])
                        H[i, j] = H[i - 1, j - 1];
                    else
                        H[i, j] = Math.Min(H[i - 1, j - 1], Math.Min(H[i - 1, j], H[i, j - 1])) + 1;
                }
            }

            // 计算相似度（此相似度未必合理）
            Int32 MaxLength = Math.Max(m, n);   // 两字符串的最大长度
            similarity = ((Double)(MaxLength - H[m, n])) / MaxLength;

            return H[m, n];    // 编辑距离
        }

        /// <summary>
        /// 受限的Damerau-Levenshtein Distance（只允许相邻字符交换）
        /// </summary>
        /// <param name="source">源串</param>
        /// <param name="target">目标串</param>
        /// <param name="similarity">输出：相似度，值在0～1</param>
        /// <param name="isCaseSensitive">是否大小写敏感</param>
        /// <returns>源串和目标串之间的编辑距离</returns>
        /// <remarks>http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance</remarks>
        public static Int32 OptimalStringAlignmentDistance(String source, String target, out Double similarity, Boolean isCaseSensitive = false)
        {
            if (String.IsNullOrEmpty(source))
            {
                if (String.IsNullOrEmpty(target))
                {
                    similarity = 1;
                    return 0;
                }
                else
                {
                    similarity = 0;
                    return target.Length;
                }
            }
            else if (String.IsNullOrEmpty(target))
            {
                similarity = 0;
                return source.Length;
            }

            String From, To;
            if (isCaseSensitive)
            {   // 大小写敏感
                From = source;
                To = target;
            }
            else
            {   // 大小写无关
                From = source.ToLower();
                To = target.ToLower();
            }

            // 初始化
            Int32 m = From.Length;
            Int32 n = To.Length;
            Int32[,] H = new Int32[m + 1, n + 1];
            for (Int32 i = 0; i <= m; i++) H[i, 0] = i;  // 注意：初始化[0,0]
            for (Int32 j = 1; j <= n; j++) H[0, j] = j;

            // 迭代
            for (Int32 i = 1; i <= m; i++)
            {
                Char SI = From[i - 1];
                for (Int32 j = 1; j <= n; j++)
                {   // 删除（deletion） 插入（insertion） 替换（substitution）
                    Char DJ = To[j - 1];
                    if (SI == DJ)
                        H[i, j] = H[i - 1, j - 1];
                    else
                        H[i, j] = Math.Min(H[i - 1, j - 1], Math.Min(H[i - 1, j], H[i, j - 1])) + 1;

                    if (i > 1 && j > 1)
                    {   // 交换相邻字符（transposition of two adjacent characters）
                        if (SI == To[j - 2] && DJ == From[i - 2])
                        {
                            H[i, j] = Math.Min(H[i, j], H[i - 2, j - 2] + 1);
                        }
                    }
                }
            }

            // 计算相似度（此相似度未必合理）
            Int32 MaxLength = Math.Max(m, n);   // 两字符串的最大长度
            similarity = ((Double)(MaxLength - H[m, n])) / MaxLength;

            return H[m, n];    // 编辑距离
        }

        /// <summary>
        /// 不受限的Damerau-Levenshtein Distance（允许交换字符间的删除插入操作）
        /// 我在维基百科中贡献了此段代码的修改版（去掉了相似度和大小写敏感）
        /// </summary>
        /// <param name="source">源串</param>
        /// <param name="target">目标串</param>
        /// <param name="similarity">输出：相似度，值在0～1</param>
        /// <param name="isCaseSensitive">是否大小写敏感</param>
        /// <remarks>http://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance</remarks>
        public static Int32 DamerauLevenshteinDistance(String source, String target, out Double similarity, Boolean isCaseSensitive = false)
        {
            if (String.IsNullOrEmpty(source))
            {
                if (String.IsNullOrEmpty(target))
                {
                    similarity = 1;
                    return 0;
                }
                else
                {
                    similarity = 0;
                    return target.Length;
                }
            }
            else if (String.IsNullOrEmpty(target))
            {
                similarity = 0;
                return source.Length;
            }

            String From, To;
            if (isCaseSensitive)
            {   // 大小写敏感
                From = source;
                To = target;
            }
            else
            {   // 大小写无关
                From = source.ToLower();
                To = target.ToLower();
            }

            // 初始化
            Int32 m = From.Length;
            Int32 n = To.Length;
            Int32[,] H = new Int32[m + 2, n + 2];

            Int32 INF = m + n;
            H[0, 0] = INF;
            for (Int32 i = 0; i <= m; i++) { H[i + 1, 1] = i; H[i + 1, 0] = INF; }
            for (Int32 j = 0; j <= n; j++) { H[1, j + 1] = j; H[0, j + 1] = INF; }

            // 对维基百科中给出ActionScript代码优化，去掉参数C，可以更好地适合各国语言
            SortedDictionary<Char, Int32> sd = new SortedDictionary<Char, Int32>();
            foreach (Char Letter in (From + To))
            {
                if (!sd.ContainsKey(Letter))
                    sd.Add(Letter, 0);
            }

            // 迭代
            for (Int32 i = 1; i <= m; i++)
            {
                Int32 DB = 0;
                for (Int32 j = 1; j <= n; j++)
                {
                    Int32 i1 = sd[To[j - 1]];   // 定位字符To[j-1]在源串From[0:i-2]中的最后一次索引
                    Int32 j1 = DB;              // 定位字符From[i-1]在目标串To[0:j-2]中的最后一次索引

                    // 删除（deletion） 插入（insertion） 替换（substitution）
                    if (From[i - 1] == To[j - 1])
                    {
                        H[i + 1, j + 1] = H[i, j];
                        DB = j;
                    }
                    else
                    {
                        H[i + 1, j + 1] = Math.Min(H[i, j], Math.Min(H[i + 1, j], H[i, j + 1])) + 1;
                    }

                    // transposition of two adjacent characters
                    // 将源串i1-1到i-1内的字符删除，然后交换i1-1和i-1的字符，再加上目标串j1-1到j-1内的字符  
                    H[i + 1, j + 1] = Math.Min(H[i + 1, j + 1], H[i1, j1] + (i - i1 - 1) + 1 + (j - j1 - 1));
                }

                sd[From[i - 1]] = i;
            }

            // 计算相似度（此相似度未必合理）
            Int32 MaxLength = Math.Max(m, n);   // 两字符串的最大长度
            similarity = ((Double)(MaxLength - H[m + 1, n + 1])) / MaxLength;

            return H[m + 1, n + 1];    // 编辑距离
        }

        /// <summary>
        /// 不受限的Damerau-Levenshtein Distance（允许交换字符间的删除插入操作）
        /// </summary>
        /// <param name="source">源串</param>
        /// <param name="target">目标串</param>
        /// <param name="similarity">输出：相似度，值在0～1</param>
        /// <param name="isCaseSensitive">是否大小写敏感</param>
        /// <remarks>更好理解的代码</remarks>
        public static Int32 EZDamerauLevenshteinDistance(String source, String target, out Double similarity, Boolean isCaseSensitive = false)
        {
            if (String.IsNullOrEmpty(source))
            {
                if (String.IsNullOrEmpty(target))
                {
                    similarity = 1;
                    return 0;
                }
                else
                {
                    similarity = 0;
                    return target.Length;
                }
            }
            else if (String.IsNullOrEmpty(target))
            {
                similarity = 0;
                return source.Length;
            }

            String From, To;
            if (isCaseSensitive)
            {   // 大小写敏感
                From = source;
                To = target;
            }
            else
            {   // 大小写无关
                From = source.ToLower();
                To = target.ToLower();
            }

            // 初始化
            Int32 m = From.Length;
            Int32 n = To.Length;
            Int32[,] H = new Int32[m + 1, n + 1];
            for (Int32 i = 0; i <= m; i++) H[i, 0] = i;  // 注意：初始化[0,0]
            for (Int32 j = 1; j <= n; j++) H[0, j] = j;

            // 迭代
            for (Int32 i = 1; i <= m; i++)
            {
                Char SI = From[i - 1];
                for (Int32 j = 1; j <= n; j++)
                {   // 删除（deletion） 插入（insertion） 替换（substitution）
                    Char DJ = To[j - 1];
                    if (SI == DJ)
                        H[i, j] = H[i - 1, j - 1];
                    else
                        H[i, j] = Math.Min(H[i - 1, j - 1], Math.Min(H[i - 1, j], H[i, j - 1])) + 1;

                    if (i > 1 && j > 1)
                    {   // 交换相邻字符（transposition of two adjacent characters）                       
                        Int32 i1 = From.LastIndexOf(DJ, i - 2, i - 1);
                        if (i1 != -1)
                        {
                            Int32 j1 = To.LastIndexOf(SI, j - 2, j - 1);
                            if (j1 != -1)
                            {   // 将源串i1到i-1内的字符删除，然后交换i1和i-1的字符，再加上目标串j1到j-1内的字符                              
                                H[i, j] = Math.Min(H[i, j], H[i1, j1] + (i - i1 - 2) + 1 + (j - j1 - 2));
                            }
                        }
                    }
                }
            }

            // 计算相似度（此相似度未必合理）
            Int32 MaxLength = Math.Max(m, n);   // 两字符串的最大长度
            similarity = ((Double)(MaxLength - H[m, n])) / MaxLength;

            return H[m, n];    // 编辑距离
        }
    }
}

 

     

 

秦建辉
关注
C#: 星座星盘计算算法
Eshine的博客
12-31 1万+
前一篇提到计算八卦五行的算法，这里要跟大家分享一个星座星盘的算法。你们可能觉得笔者怎么开始研究这些玄幻的东西了，确实笔者觉得有一些真的是很扯，不过笔者的目的是为了研究大数据。好了，说到星盘笔者发现新浪星座有个很不错的星盘解说的http://astro.sina.com.cn/pc/zodiac.html大家可以试一下，笔者就觉得分析出来的星盘那个图很不错看起来很专业，图里面的也是数据格式的而不是底
C# 判断两条直线距离
lindexi
06-29 2515
本文告诉大家获得两条一般式直线距离
一个简单的字符串Edit Distance C#程序
07-12
一个简单的字符串Edit Distance C#程序
编辑距离算法（C#版本）
weixin_30429201的博客
12-24 213
根据java版本移植 View Code 1 /// <summary> 2 /// 编辑距离算法 3 /// </summary> 4 public class EditDistance 5 { 6 /** 7 * 求三个数中的最小数Mar 1, 2007 8 ...
C#通过编辑距离算法实现字符串相似度比较的代码
stalk58的博客
07-26 216
如下内容段是关于C#通过编辑距离算法实现字符串相似度比较的内容，希望能对各位有所帮助。 public class LevenshteinDistance { private static LevenshteinDistance _instance=null; public static LevenshteinDistance Instance ...
编辑距离算法以及它的C#实现
weixin_30915951的博客
09-30 148
原文：https://www.cnblogs.com/shihuajie/p/5772173.html 注意，原文中有以下表述不当的地方 “扫描两字符串（n*m级的），如果：str1== str2[j]”应该改为“扫描两字符串（n*m级的），如果：str1[i]== str2[j]”.并且，这里的扫描如果放在矩阵里面实现的话，其实是i-1和j-1（因为矩阵下标为1的位置对应的实际是字符串...
C字符串相似度计算
Sam萨姆
08-12 2792
#region 计算相似度         ///         /// 取最小的一位数         ///         ///         ///         ///         ///         public static int LowerOfThree(int first, int second, int third)      
设计模式：基于C#的工程化实现及扩展.pdf
03-08
设计模式：基于C#的工程化实现及扩展
C#: 计算 两个日期之间的 时间差
JeterPong's Column
05-11 9355
前言：想知道过去的某个时间到现在过了多久，经历多少天，甚至精确到分。查阅了一下资料后，自己写了一个方法实现，基本达到要求，效果杠杠哒。ヾ(๑╹◡╹)ﾉ"时间的输入格式：日期(年月日)必须以逗号（，）、空格（ ）、 破折号（-）分隔开，时间(时分秒)以冒号分隔；如：string ss = "2017,7,15,20:16:35";  // "2017,7,15 20:16:35" 、"2017,7,...
C#进化计算：遗传算法源代码
08-04
《C#进化计算：遗传算法源代码》是一个深入探讨如何在C#编程环境中实现遗传算法的资源。遗传算法是人工智能领域中的一个重要分支，它模仿了自然界中的生物进化过程，通过模拟选择、交叉和变异等机制来求解复杂问题。...
c#字符串相似度源码 编辑距离 余弦相似性 SimHash
05-22
C#源码,演示字符串相似度 编辑距离 余弦相似性 SimHash算法
C# 开源 Wiki 系统，架构不错，支持多种 DataProvider
04-28
C# 开源 Wiki 系统，架构不错，支持多种 DataProvider,默认为文件数据库，很方便！
C# 利用编辑距离算法查重（非构建二维数组）
qq_25421741的博客
04-09 555
C# 利用编辑距离算法查重（一维数组） 最近在项目中，被要求对相关上传文本需进行高精度查重，网上进行了相关搜索，根据理论实现的编辑距离算法皆为二维数组，对于几千字的文本进行查重，构建数组时将直接导致内存溢出。这里将网上大神对于C语言中进行查重算法的转化，转为一维数组。记录下算法，以便日后使用 /// <summary> /// 文本相似度（编辑距离算法，精度最高，花费...
Edit Distance (编辑距离) .NET 实现
Van Pan 的专栏
11-14 1274
/// /// Calculate Text Edit Distance Utility Class /// public static class TextEditDistanceUtility { /// /// get edit distance between two string ///
详解编辑距离(Edit Distance)及其代码实现
木东的博客
06-04 1395
概述 编辑距离（Minimum Edit Distance，MED），由俄罗斯科学家 Vladimir Levenshtein 在1965年提出，也因此而得名 Levenshtein Distance。 在信息论、语言学和计算机科学领域，Levenshtein Distance 是用来度量两个序列相似程度的指标。通俗地来讲，编辑距离指的是在两个单词之间，由其中一个单词转换为另一个单词所需要的最少单字符编辑操作次数。 在这里定义的单字符编辑操作有且仅有三种： 插入（Insertion） 删除（Del
【C#】C#匹配两个相似的字符串莱文斯坦距离Levenshtein Distance莱文斯坦距离算法
最新发布
JosieBook
04-11 590
莱文斯坦字符串相似度匹配
C#实现：二叉树实时计算海量用户积分排名
"在C#中使用二叉树实时计算海量用户积分排名的实现详解" 本文将详细介绍如何在C#环境中利用二叉树实现对大量用户积分的实时排名计算。二叉树作为一种高效的搜索数据结构，可以有效地处理实时计算的问题，避免了传统...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值