提高字符串数组自定义排序的性能

Question

我试图找到一种有效的方法来根据数组的每个字符串元素中的数值对字符串数组进行排序。我目前正在使用 Array.Sort(array, customComparer) 静态方法（快速排序），我的自定义比较器类（按降序排序）是：

class StringComparer : IComparer<string>
{
    public int Compare(string a, string b)
    {
        string s1 = a;
        string s2 = b;

        Match matchA = Regex.Match(s1, @"\d+$");
        Match matchB = Regex.Match(s2, @"\d+$");

        long numberA = long.Parse(matchA.Value);
        long numberB = long.Parse(matchB.Value);

        if (numberB - numberA < 0)
        {
            return -1;
        }
        else 
        {
            return 1;
        }
    }
}

这很好用，但有时排序需要花费太多时间，在 2.4Ghz 处理器上，一个包含 100 000 个字符串的数组需要花费超过一分钟的时间。我想知道是否有更有效的方法来完成同样的事情。例如，实现不同的排序算法或采用另一种方法，例如使用字典并对值进行排序（该值是字符串的数字部分）。有什么建议？提前致谢！

Answer 1

首先，您不必要地一遍又一遍地解析相同的字符串（都与正则表达式匹配，然后解析匹配项）。相反，将您拥有的内容封装到自定义类型中，这样您只需解析一次。

public class FooString {
    private readonly string foo;
    private readonly long bar;

    public FooString(string foo) {
        this.foo = foo;
        Match match = Regex.Match(foo, @"\d+$");
        this.bar = Int64.Parse(match.Value);
    }

    public string Foo { get { return this.foo; } }
    public long Bar { get { return this.bar; } }
}

我什至会在这个类中添加一个Contract.Requires，说明foo 必须满足正则表达式。

其次，您有一个IComparer<T>，它在T 的某些值上死掉（在您的情况下，strings 与正则表达式不匹配并且无法解析为long）。这通常是个坏主意。

所以，为FooString 做比较器：

public FooStringComparer : IComparer<FooString> {
    public int Compare(FooString a, FooString b) {
        Contract.Requires(a != null);
        Contract.Requires(b != null);
        return a.Bar.CompareTo(b.Bar);
    }
}

现在，您的排序将非常快，因为您已经停止了一遍又一遍地解析相同的字符串。

Answer 2

您现在正在执行正则表达式 O(n log n) 次。

考虑对所有字符串循环一次，提取数值并将其添加到SortedDictionary<long, string>

这只需要 O(n) 次 Reg 表达式的执行。其余的排序应该是可比的。

Answer 3

使用Compiled 选项仅创建一次Regex。这将提高速度。

class StringComparer : IComparer<string>
{
    private static Regex _regex = new Regex(@"\d+$", RegexOptions.Compiled);

    public int Compare(string a, string b)
    {
        long numberA = Int64.Parse(_regex.Match(a).Value);
        long numberB = Int64.Parse(_regex.Match(b).Value);
        return numberA.CompareTo(numberB);
    }
}

Answer 4

您正在解析每次比较的值。我建议你解析一次，得到一个字符串/长对，排序，然后提取字符串部分。

请注意，您现有的代码有一个错误：对于两个比较相等的字符串，它将永远返回 0。

这是使用 LINQ 的另一种方法（不是就地排序，但很简单。）

var sorted = unsorted.OrderBy(x => long.Parse(Regex.Match(x, @"\d+$").Value));
                     .ToList();

（OrderBy 进行一次获取密钥，然后比较密钥。）