Why does .NET Sort algorithm request comparisons of items against themselves?

Question

I've noticed that when sorting an array in .NET using a custom IComparer<T>, requests are made for comparisons of an item against itself.

Why is this the case? Surely it's a trivial optimization to see if a comparison is about to be made of identical indexes, and assume the result must be zero?

Example code:

class Comparer : IComparer<string>
{
  public int Compare(string x, string y)
  {
    Console.WriteLine("{0} vs {1}", x, y);

    return string.Compare(x, y);
  }
}

static void Main(string[] args)
{
  var values = new[] {"A", "D", "C", "B", "E"};

  Array.Sort(values, new Comparer());
}

With output (strange comparisons marked):

A vs C
A vs E
C vs E
A vs C
D vs C
C vs E
C vs B
C vs C   ***
C vs C   ***
A vs B
A vs B
A vs A   ***
A vs B
A vs A   ***
D vs E
D vs E
D vs D   ***
D vs E
D vs D   ***

Can't reproduce, my output: D vs A C vs D C vs A B vs D B vs C B vs A E vs D — Albin Sunnanbo, Nov 12 '12 at 12:10
Hmmm... I'm using .NET 4 and I do get the 'rogue' comparisons. — stusmith, Nov 12 '12 at 12:16
@HansPassant: I ran inside LinqPad 4 (.NET 4) and still got the same result. — Jon, Nov 12 '12 at 12:16
Although the optimization seems trivial the question is if that helps overall performance (cpu-ticks, memory), assuming the goal is optimal performance. — rene, Nov 12 '12 at 12:24
related: http://stackoverflow.com/questions/7373652/in-the-listt-sort-method-is-an-item-ever-compared-to-itself Note that the sorting method has changed in .NET 4.0, from Quicksort to Introsort — Paolo Moretti, Nov 12 '12 at 12:29

score 3 · Accepted Answer · edited Nov 12 '12 at 14:47

People report different outcomes because the Array.Sort() algorithm was changed several times. At least in .NET 4.0 and again in .NET 4.5, possibly before that. The latest and greatest version switched from QuickSort to Introsort.

You are seeing an element compared by itself due to a counter-measure against Quicksort's very poor worst case behavior, O(n^2). The Wikipedia article for Introsort explains it well:

In quicksort, one of the critical operations is choosing the pivot: the element around which the list is partitioned. The simplest pivot selection algorithm is to take the first or the last element of the list as the pivot, causing poor behavior for the case of sorted or nearly sorted input. Niklaus Wirth's variant uses the middle element to prevent these occurrences, degenerating to O(n²) for contrived sequences. The median-of-3 pivot selection algorithm takes the median of the first, middle, and last elements of the list; however, even though this performs well on many real-world inputs, it is still possible to contrive a median-of-3 killer list that will cause dramatic slowdown of a quicksort based on this pivot selection technique. Such inputs could potentially be exploited by an aggressor, for example by sending such a list to an Internet server for sorting as a denial of service attack.

You are seeing the side-effects of the the median-of-3 pivot selection algorithm.

Why does .NET Sort algorithm request comparisons of items against themselves?

1 Answers1