c# 字符串相似度比较代码

你可以使用C#的字符串比较方法来计算两个字符串之间的相似度。常用的算法有Levenshtein距离和Jaro-Winkler距离。下面是使用这两种算法计算字符串相似度的示例代码：

using System;

class Program
{
    static void Main(string[] args)
    {
        string str1 = "hello";
        string str2 = "hallo";

        double levenshteinDistance = LevenshteinDistance(str1, str2);
        double jaroWinklerDistance = JaroWinklerDistance(str1, str2);

        Console.WriteLine("Levenshtein Distance: " + levenshteinDistance);
        Console.WriteLine("Jaro-Winkler Distance: " + jaroWinklerDistance);
    }

    static double LevenshteinDistance(string s, string t)
    {
        int n = s.Length;
        int m = t.Length;
        int[,] d = new int[n + 1, m + 1];

        if (n == 0)
        {
            return m;
        }

        if (m == 0)
        {
            return n;
        }

        for (int i = 0; i <= n; i++)
        {
            d[i, 0] = i;
        }

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

        for (int j = 1; j <= m; j++)
        {
            for (int i = 1; i <= n; i++)
            {
                int cost = (s[i - 1] == t[j - 1]) ? 0 : 1;

                d[i, j] = Math.Min(Math.Min(
                    d[i - 1, j] + 1,
                    d[i, j - 1] + 1),
                    d[i - 1, j - 1] + cost);
            }
        }

        return 1.0 - (double)d[n, m] / Math.Max(n, m);
    }

    static double JaroWinklerDistance(string s, string t)
    {
        int sLen = s.Length;
        int tLen = t.Length;

        if (sLen == 0 && tLen == 0)
        {
            return 1.0;
        }

        int matchDistance = Math.Max(sLen, tLen) / 2 - 1;

        bool[] sMatches = new bool[sLen];
        bool[] tMatches = new bool[tLen];

        int matches = 0;
        for (int i = 0; i < sLen; i++)
        {
            int start = Math.Max(0, i - matchDistance);
            int end = Math.Min(i + matchDistance + 1, tLen);

            for (int j = start; j < end; j++)
            {
                if (tMatches[j])
                {
                    continue;
                }

                if (s[i] != t[j])
                {
                    continue;
                }

                sMatches[i] = true;
                tMatches[j] = true;
                matches++;
                break;
            }
        }

        if (matches == 0)
        {
            return 0.0;
        }

        int tPrefix = 0;
        for (int i = 0; i < tLen && tMatches[i]; i++)
        {
            tPrefix++;
        }

        double jaro = ((double)matches / sLen + (double)matches / tLen + (double)(matches - tPrefix) / matches) / 3;

        int j = 0;
        while (j < Math.Min(sLen, 4) && s[j] == t[j])
        {
            j++;
        }

        if (j == 0)
        {
            return jaro;
        }

        double jaroWinkler = jaro + Math.Min(0.1, 1.0 / Math.Max(sLen, tLen) * j * (1.0 - jaro));

        return jaroWinkler;
    }
}

在上面的示例中，`LevenshteinDistance`方法使用Levenshtein距离算法计算字符串相似度，并返回一个介于0和1之间的值。这个值越接近1，表示两个字符串越相似。

`JaroWinklerDistance`方法使用Jaro-Winkler距离算法计算字符串相似度，并返回一个介于0和1之间的值。这个值越接近1，表示两个字符串越相似。Jaro-Winkler距离算法还考虑了字符串的前缀匹配，因此对于具有相同前缀的字符串，它的结果会更准确。