我正在寻找一种方法来比较字符串和字符串数组。当然，进行精确搜索非常容易，但我希望我的程序能够容忍拼写错误，缺少部分字符串等等。
是否有某种框架可以执行此类搜索？我有一些想法，搜索算法将按匹配百分比或类似的方式返回一些结果顺序。
答案 0 :(得分：64)
您可以使用Levenshtein Distance algorithm。
“两个字符串之间的Levenshtein距离定义为将一个字符串转换为另一个字符串所需的最小编辑数，允许的编辑操作是插入，删除或替换单个字符。” - Wikipedia.com
这是来自dotnetperls.com：
using System;
/// <summary>
/// Contains approximate string matching
/// </summary>
static class LevenshteinDistance
{
/// <summary>
/// Compute the distance between two strings.
/// </summary>
public static int Compute(string s, string t)
{
int n = s.Length;
int m = t.Length;
int[,] d = new int[n + 1, m + 1];
// Step 1
if (n == 0)
{
return m;
}
if (m == 0)
{
return n;
}
// Step 2
for (int i = 0; i <= n; d[i, 0] = i++)
{
}
for (int j = 0; j <= m; d[0, j] = j++)
{
}
// Step 3
for (int i = 1; i <= n; i++)
{
//Step 4
for (int j = 1; j <= m; j++)
{
// Step 5
int cost = (t[j - 1] == s[i - 1]) ? 0 : 1;
// Step 6
d[i, j] = Math.Min(
Math.Min(d[i - 1, j] + 1, d[i, j - 1] + 1),
d[i - 1, j - 1] + cost);
}
}
// Step 7
return d[n, m];
}
}
class Program
{
static void Main()
{
Console.WriteLine(LevenshteinDistance.Compute("aunt", "ant"));
Console.WriteLine(LevenshteinDistance.Compute("Sam", "Samantha"));
Console.WriteLine(LevenshteinDistance.Compute("flomax", "volmax"));
}
}
您实际上可能更喜欢使用Damerau-Levenshtein distance algorithm，这也允许转置字符，这是数据输入中常见的人为错误。你会发现它的C＃实现here。
答案 1 :(得分：20)
.NET框架中没有任何内容可以帮助您开箱即用。
最常见的拼写错误是那些字母是单词的正确语音表示，而不是单词的正确拼写。
例如，可以认为单词sword和sord（是的，这是一个单词）具有相同的语音词根（当你发音时它们的声音相同）。
话虽如此，有许多算法可用于将单词（甚至是拼错的单词）翻译成语音变体。
第一个是Soundex。它实现起来相当简单，并且有相当数量的.NET implementations of this algorithm。它相当简单，但它为您提供了可以相互比较的真实值。
另一个是Metaphone。虽然我找不到Metaphone的原生.NET实现，但所提供的链接还包含许多可以转换的其他实现的链接。最容易转换的可能是Java implementation of the Metaphone algorithm。
应该注意的是，Metaphone算法已经过修订。有Double Metaphone（有.NET implementation）和Metaphone 3。 Metaphone 3是商业应用程序，但准确率为98％，而Double Metaphone算法在针对普通英语单词数据库运行时的准确率为89％。根据您的需要，您可能希望寻找（在Double Metaphone的情况下）或购买（在Metaphone 3的情况下）算法的来源并通过P / Invoke层转换或访问它（有C ++实现）比比皆是）。
Metaphone和Soundex在Soundex生成固定长度数字键的意义上有所不同，而Metaphone生成不同长度的键，因此结果会有所不同。最后，两者都会为你做同样的比较，你必须根据你的要求和资源（当然还有拼写错误的不容忍程度）找出最适合你需求的东西。
答案 2 :(得分：5)
这是LevenshteinDistance方法的一个实现，它使用更少的内存，同时产生相同的结果。这是在{Intrative with two matrix rows'标题下的wikipedia article中找到的伪代码的C＃改编。
public static int LevenshteinDistance(string source, string target)
{
// degenerate cases
if (source == target) return 0;
if (source.Length == 0) return target.Length;
if (target.Length == 0) return source.Length;
// create two work vectors of integer distances
int[] v0 = new int[target.Length + 1];
int[] v1 = new int[target.Length + 1];
// initialize v0 (the previous row of distances)
// this row is A[0][i]: edit distance for an empty s
// the distance is just the number of characters to delete from t
for (int i = 0; i < v0.Length; i++)
v0[i] = i;
for (int i = 0; i < source.Length; i++)
{
// calculate v1 (current row distances) from the previous row v0
// first element of v1 is A[i+1][0]
// edit distance is delete (i+1) chars from s to match empty t
v1[0] = i + 1;
// use formula to fill in the rest of the row
for (int j = 0; j < target.Length; j++)
{
var cost = (source[i] == target[j]) ? 0 : 1;
v1[j + 1] = Math.Min(v1[j] + 1, Math.Min(v0[j + 1] + 1, v0[j] + cost));
}
// copy v1 (current row) to v0 (previous row) for next iteration
for (int j = 0; j < v0.Length; j++)
v0[j] = v1[j];
}
return v1[target.Length];
}
这是一个可以提供相似百分比的函数。
/// <summary>
/// Calculate percentage similarity of two strings
/// <param name="source">Source String to Compare with</param>
/// <param name="target">Targeted String to Compare</param>
/// <returns>Return Similarity between two strings from 0 to 1.0</returns>
/// </summary>
public static double CalculateSimilarity(string source, string target)
{
if ((source == null) || (target == null)) return 0.0;
if ((source.Length == 0) || (target.Length == 0)) return 0.0;
if (source == target) return 1.0;
int stepsToSame = LevenshteinDistance(source, target);
return (1.0 - ((double)stepsToSame / (double)Math.Max(source.Length, target.Length)));
}
答案 3 :(得分：4)
您的另一个选择是使用Soundex或Metaphone进行语音比较。我刚刚完成了一篇文章，介绍了两种算法的C＃代码。您可以在http://www.blackbeltcoder.com/Articles/algorithms/phonetic-string-comparison-with-soundex查看。
答案 4 :(得分：3)
以下两种方法可以计算字符串之间的Levenshtein Distance。
两个字符串之间的Levenshtein距离定义为将一个字符串转换为另一个字符串所需的最小编辑数，允许的编辑操作是插入，删除或替换单个字符。
获得结果后，您需要定义要用作匹配阈值的值。在一堆样本数据上运行该函数，以便更好地了解它是如何工作的，以帮助确定您的特定阈值。
/// <summary>
/// Calculates the Levenshtein distance between two strings--the number of changes that need to be made for the first string to become the second.
/// </summary>
/// <param name="first">The first string, used as a source.</param>
/// <param name="second">The second string, used as a target.</param>
/// <returns>The number of changes that need to be made to convert the first string to the second.</returns>
/// <remarks>
/// From http://www.merriampark.com/ldcsharp.htm
/// </remarks>
public static int LevenshteinDistance(string first, string second)
{
if (first == null)
{
throw new ArgumentNullException("first");
}
if (second == null)
{
throw new ArgumentNullException("second");
}
int n = first.Length;
int m = second.Length;
var d = new int[n + 1, m + 1]; // matrix
if (n == 0) return m;
if (m == 0) return n;
for (int i = 0; i <= n; d[i, 0] = i++)
{
}
for (int j = 0; j <= m; d[0, j] = j++)
{
}
for (int i = 1; i <= n; i++)
{
for (int j = 1; j <= m; j++)
{
int cost = (second.Substring(j - 1, 1) == first.Substring(i - 1, 1) ? 0 : 1); // cost
d[i, j] = Math.Min(
Math.Min(
d[i - 1, j] + 1,
d[i, j - 1] + 1),
d[i - 1, j - 1] + cost);
}
}
return d[n, m];
}
答案 5 :(得分：2)
您可以在开源CommonLibrary.NET project中找到soundex和levenshtein距离算法的实现。