比较字符串与容差

Question

我正在寻找一种方法来比较字符串和字符串数组.当然,进行精确搜索非常容易,但我希望我的程序能够容忍拼写错误,缺少部分字符串等等.

是否有某种框架可以执行这样的搜索？我有一些想法,搜索算法将返回一些结果顺序的匹配百分比或类似的东西.

Answer 1

您可以使用Levenshtein距离算法.

"两个字符串之间的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距离算法,该算法还允许转换字符,这是数据输入中常见的人为错误.你会在这里找到它的C#实现.

Answer 2

.NET框架中没有任何内容可以帮助您实现这一开箱即用的功能.

最常见的拼写错误是那些字母是单词的正确语音表示,但不是单词的正确拼写.

例如,可以认为单词sword和sord(是的,这是一个单词)具有相同的语音词根(当你发音时它们听起来相同).

话虽这么说,你可以使用许多算法将单词(甚至是拼错的单词)翻译成语音变体.

第一个是Soundex.它实现起来相当简单,并且该算法有相当多的.NET实现.它相当简单,但它为您提供了可以相互比较的真实值.

另一个是Metaphone.虽然我找不到Metaphone的原生.NET实现,但所提供的链接还包含许多可以转换的其他实现的链接.最容易转换的可能是Metaphone算法的Java实现.

应该注意的是,Metaphone算法已经过修订.有Double Metaphone(有.NET实现)和Metaphone 3.Metaphone 3是商业应用程序,但准确率为98%,而Double Metaphone算法在针对普通英语单词数据库运行时的准确率为89%.根据您的需要,您可能希望寻找(在Double Metaphone的情况下)或购买(在Metaphone 3的情况下)算法的来源并通过P/Invoke层转换或访问它(有C++实现)盛产).

Metaphone和Soundex在Soundex生成固定长度数字键的意义上有所不同,而Metaphone生成不同长度的键,因此结果会有所不同.最后,两者都会为你做同样的比较,你必须根据你的要求和资源(当然还有拼写错误的不宽容等级)找出最适合你需求的东西.

Answer 3

您的另一个选择是使用Soundex或Metaphone在语音上进行比较。我刚刚完成了一篇介绍两种算法的C＃代码的文章。您可以在http://www.blackbeltcoder.com/Articles/algorithms/phonetic-string-comparison-with-soundex上查看它。

Answer 4

这是LevenshteinDistance方法的实现，该方法在产生相同结果的同时使用更少的内存。这是在Wikipedia文章中“带有两个矩阵行的迭代”标题下找到的伪代码的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)));
}