C#，字符串相似度的莱文斯坦距离（Levenshtein Distance）算法与源代码

一、莱文斯坦（Levenshtein）

Vladimir I. Levenshtein

弗拉基米尔·I·列文施坦博士是纠错码理论的先驱，被称为俄罗斯编码理论之父。Levenshtein是莫斯科俄罗斯科学院Keldysh应用数学研究所的研究教授，他的贡献体现在消费者的日常生活中。他的“Levenshtein距离”或“编辑距离”是当今拼写检查计算机应用的根源；他还为第三代有线蜂窝电话的基础技术做出了贡献。

Levenshtein博士为度量空间（包括Hamming空间和欧几里德球面）中的代码和设计的最佳大小提供了最著名的通用边界。特别是，他们发现了长期以来寻找的n=8和n=24的接吻数字。Levenshtein博士为几个纠错问题撰写了最佳结构，包括：纠正四分之一或更多错误的代码；具有给定的无逗号索引的代码；完美的代码能够纠正单次删除和单峰位移；以及具有给定未检测错误概率的二进制代码。他在整数的通用高效编码方面的工作导致了算法在数据压缩方面提供了有前途的应用。

Levenshtein距离及其设计和界限广泛应用于许多工程、统计学和生物信息学应用中。他最近的一项研究是基于对几个损坏副本的观察，对信息进行有效解码，这项研究预计将在计算机科学、分子生物学、DNA分析、语音识别甚至剽窃检测等多个领域得到应用。

作为一名IEEE研究员，他是莫斯科数学学会的成员。

二、莱文斯坦距离（Levenshtein Distance）

莱文斯坦距离（Levenshtein Distance）用于衡量两个字符串之间的相似度。
莱文斯坦距离以俄国科学家（Vladimir I. Levenshtein）命名，他于1965年发明了这个算法。
莱文斯坦距离，是编辑距离（Edit Distance）的一种。
编辑距离一般是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。允许的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。
比如：两个字符串分别为a和b。
莱文斯坦距离被定义为：将字符串a变换为字符串b所需的删除、插入、替换操作的次数Ld。
 

 （比较稳定的非递归算法）源程序：

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
	public static partial class StringSearch
	{
		public static int Levenshtein_Distance(string str1, string str2)
		{
			int n = str1.Length;
			int m = str2.Length;
			if (n == 0)
			{
				return m;
			}
			if (m == 0)
			{
				return n;
			}

			int[,] matrix = new int[n + 1, m + 1];
			for (int i = 0; i <= n; i++)
			{
				matrix[i, 0] = i;
			}

			for (int j = 0; j <= m; j++)
			{
				matrix[0, j] = j;
			}

			for (int i = 1; i <= n; i++)
			{
				for (int j = 1; j <= m; j++)
				{
					int temp = (str1[i - 1] == str2[j - 1]) ? 0 : 1;
					matrix[i, j] = Triple_minium(matrix[i - 1, j] + 1, matrix[i, j - 1] + 1, matrix[i - 1, j - 1] + temp);
				}
			}
			return matrix[n, m];
		}

        private static int Triple_minium(int a, int b, int c)
		{
			return (a <= b && a <= c) ? a : ((b <= a && b <= c) ? b : c);
        }
    }
}

递归算法：

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
	public static partial class StringSearch
	{
		private static int Triple_minium(int a, int b, int c)
		{
			return (a <= b && a <= c) ? a : ((b <= a && b <= c) ? b : c);
		}

		public static int Levenshtein_Distance_Recurse_Original(string str1, int m, string str2, int n)
		{
			if (m == 0)
			{
				return n;
			}
			if (n == 0)
			{
				return m;
			}
			if (str1[m - 1] == str2[n - 1])
			{
				return Levenshtein_Distance_Recurse_Original(str1, m - 1, str2, n - 1);
			}
			int d1 = Levenshtein_Distance_Recurse_Original(str1, m, str2, n - 1);
			int d2 = Levenshtein_Distance_Recurse_Original(str1, m - 1, str2, n);
			int d3 = Levenshtein_Distance_Recurse_Original(str1, m - 1, str2, n - 1);

			return (1 + Triple_minium(d1, d2, d3));
		}
    }
}

矩阵双向迭代法的源代码：

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;

namespace Legalsoft.Truffer.Algorithm
{
	public static partial class StringSearch
	{
		public static int Levenshtein_Distance_2Directions(string str1, string str2)
		{
			int m = str1.Length;
			int n = str2.Length;
			int[,] L = new int[m + 1, n + 1];
			for (int i = 0; i <= m; i++)
			{
				for (int j = 0; j <= n; j++)
				{
					if (i == 0 || j == 0)
					{
						L[i, j] = 0;
					}
					else if (str1[i - 1] == str2[j - 1])
					{
						L[i, j] = L[i - 1, j - 1] + 1;
					}
					else
					{
						L[i, j] = Math.Max(L[i - 1, j], L[i, j - 1]);
					}
				}
			}
			int lcs = L[m, n];
			return (m - lcs) + (n - lcs);
		}
	}
}

——————————————————————

POWER BY TRUFFER.CN