对其中包含 NaN 的 Doubles 数组进行排序

Question

这更像是一个“你能解释一下这个”类型的问题，而不是其他任何问题。

我在工作中遇到了一个问题，我们在表格中使用 NaN 值，但是当对表格进行排序时，它以一种非常奇怪的方式出现。我认为 NaN 搞砸了，所以我写了一个测试应用程序来看看这是否属实。这就是我所做的。

static void Main(string[] args)
{
    double[] someArray = { 4.0, 2.0, double.NaN, 1.0, 5.0, 3.0, double.NaN, 10.0, 9.0, 8.0 };

    foreach (double db in someArray)
    {
        Console.WriteLine(db);
    }

    Array.Sort(someArray);
    Console.WriteLine("\n\n");
    foreach (double db in someArray)
    {
        Console.WriteLine(db);
    }

    Console.ReadLine();
}

结果如下：

之前：

4,2,NaN,1,5,3,NaN,10,9,8

之后：

1,4,NaN,2,3,5,8,9,10,NaN

所以是的，NaN 是如何使排序后的数组以一种奇怪的方式排序的。

引用弗莱的话； “为什么是那些东西？”

Answer 1

我相信那是因为

a < NaN == false
a > NaN == false
a == NaN == false

因此，对它们的比较会失败，从而导致整个排序失败。

Answer 2

编辑（结论。最终。结束。）：这是一个错误。

请参阅错误报告 Bug in List<double/single>.Sort() [.NET35] in list which contains double.NaN，然后在 Why does .NET 4.0 sort this array differently than .NET 3.5? 上给 Hans Passant 投赞成票，我从那里撕掉了链接。

历史沉思

[请参阅帖子：Why does .NET 4.0 sort this array differently than .NET 3.5?，希望在此特殊问题上可以找到更多有用的讨论。我也在那里交叉发布了这个回复。]

Phil 在 .NET4 中指出的行为是在 CompareTo 中定义的。对于 .NET4，请参阅 double.CompareTo。这与 .NET35 中的行为相同，但是根据方法文档，应该在两个版本中保持一致...

Array.Sort(double[]): 似乎没有像预期的那样使用CompareTo(double[])，这很可能是一个错误——注意 Array.Sort(object[]) 和 Array.Sort(double []) 下方。我希望对以下内容进行澄清/更正。

无论如何，使用> 和< 和== 的答案解释了为什么这些运算符不起作用，但无法解释为什么@987654333 @ 导致意外输出。以下是我的一些发现，尽管它们可能是微不足道的。

首先，double.CompareTo(T) 方法的文档——这个顺序是根据文档明确定义的：

小于零： 此实例小于值。 -要么- 此实例不是数字 (NaN)，值是数字。

零： 这个实例等于值。 -要么- 此实例和值都不是数字 (NaN)、PositiveInfinity 或 NegativeInfinity。

大于零： 此实例大于值。 -要么- 此实例是一个数字，值不是一个数字 (NaN)。

在 LINQPad（3.5 和 4，两者的结果相同）：

0d.CompareTo(0d).Dump();                  // 0
double.NaN.CompareTo(0d).Dump();          // -1
double.NaN.CompareTo(double.NaN).Dump();  // 0
0d.CompareTo(double.NaN).Dump();          // 1

使用CompareTo(object) 有相同的结果：

0d.CompareTo((object)0d).Dump();                  // 0
double.NaN.CompareTo((object)0d).Dump();          // -1
double.NaN.CompareTo((object)double.NaN).Dump();  // 0
0d.CompareTo((object)double.NaN).Dump();          // 1

所以这不是问题。

现在，从Array.Sort(object[]) 文档来看——没有使用>、< 或==（根据文档）——只有CompareTo(object)。

使用数组中每个元素的IComparable 实现对整个一维数组中的元素进行排序。

同样，Array.Sort(T[]) 使用 CompareTo(T)。

使用 Array 的每个元素的 IComparable(Of T) 通用接口实现对整个 Array 中的元素进行排序。

让我们看看：

LINQPad (4)：

var ar = new double[] {double.NaN, 0, 1, double.NaN};
Array.Sort(ar);
ar.Dump();
// NaN, NaN, 0, 1

LINQPad (3.5)：

var ar = new double[] {double.NaN, 0, 1, double.NaN};
Array.Sort(ar);
ar.Dump();
// NaN, 0, NaN, 1

LINQPad (3.5) -- 注意数组是对象，并且行为是根据CompareTo 合同“预期的”。

var ar = new object[] {double.NaN, 0d, 1d, double.NaN};
Array.Sort(ar);
ar.Dump();
// NaN, NaN, 0, 1

嗯。真的。总结：

我不知道。

编码愉快。

Answer 3

从概念上讲，NaN 不是数字，因此与数字进行比较是没有意义的，因此：

a < NaN = false for all a,
a > NaN = false for all a and
NaN != NaN (!)

要解决这个问题，您需要编写自己的比较器，该比较器使用 IsNaN 使 NaN 小于（或大于）所有数字，以便它们都出现在排序的一端。

编辑：这是比较版本的示例：

class Program
{
    private static int NaNComparison(double first, double second)
    {
        if (double.IsNaN(first))
        {
            if (double.IsNaN(second)) // Throws an argument exception if we don't handle both being NaN
                return 0;
            else
                return -1;
        }
        if (double.IsNaN(second))
            return 1;

        if (first == second)
            return 0;
        return first < second ? -1 : 1;
    }

    static void Main(string[] args)
    {
        var doubles = new[] { double.NaN, 2.0, 3.0, 1.0, double.NaN };

        Array.Sort(doubles, NaNComparison);
    }
}

Answer 4

实际上，奇怪的排序行为是 .NET 3.5 中的一个错误造成的。该错误已在 .NET 4.0 中得到解决。

解决此问题的唯一方法是使用您自己的自定义比较器，或升级到 .NET 4.0。见Why does .NET 4.0 sort this array differently than .NET 3.5?

Answer 5

因为您使用的是默认排序，即快速排序算法；该实现执行不稳定的排序；也就是说，如果两个元素相等，则可能不会保留它们的顺序