Schnellste Möglichkeit, ein Array in absteigender Reihenfolge zu sortieren

Warum ist der folgende code

Array.Sort(values);
Array.Reverse(values);

viel schneller beim Sortieren eines Arrays in absteigender Reihenfolge im Vergleich zu

Array.Sort(values, (a,b)=>(-a.CompareTo(b)));

Code ausgeführt wurde, in den Release-Modus, die außerhalb des Debuggers.

Was ist die effizienteste Weise zu produzieren, die eine absteigende Sortierung für arrays, vorzugsweise in einem one-liner?

InformationsquelleAutor der Frage Projectile Fish | 2011-07-27

  1. 20

    Das ist eine gute Frage. Ich Wette, Ihre Werte-array ist ein array von primitiven Typ!

    Es ist wirklich die Art, die hier herrscht, weil die Komplexität der Rückseite ist O(n), während das Sortieren ist O(n logn).

    Die Sache ist, dass beim Sortieren von primitiven Typen .NETTO ruft tatsächlich eine native Funktion, die extrem schnell - viel schneller, mit einem Vergleich oder Komparator.

    Die Funktion aufgerufen wird TrySZSort:

    [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
[SecurityCritical]
[MethodImpl(MethodImplOptions.InternalCall)]
private static bool TrySZSort(Array keys, Array items, int left, int right);

    und hier ist, wie es heißt in der Array-Klasse:

    [ReliabilityContract(Consistency.MayCorruptInstance, Cer.MayFail)]
[SecuritySafeCritical]
public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer)
{
  if (array == null)
    throw new ArgumentNullException("array");
  else if (index < 0 || length < 0)
    throw new ArgumentOutOfRangeException(length < 0 ? "length" : "index", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  else if (array.Length - index < length)
    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
  else if (length > 1 && (comparer != null && comparer != Comparer<T>.Default || !Array.TrySZSort((Array) array, (Array) null, index, index + length - 1)))
    ArraySortHelper<T>.Default.Sort(array, index, length, comparer);
}

    InformationsquelleAutor der Antwort Petar Ivanov

  2. 4

    Als link Punkte aus

    Sort-Methode, hier immer endet in einer internen TrySZSort oder QuickSort
    Methode, wenn es nicht eine Ausnahme werfen. Die TrySZSort interne
    Methode ist optimiert für die ein-dimensionale arrays, auch bekannt als "Zero"
    arrays oder Vektoren

    Weil die TrySZSort Methode verwendet, die in der base class libraries ist
    umgesetzt, die in nativem code, es wurde stark optimiert. Daher
    diese Methode ist wahrscheinlich schneller als jede Lösung, geschrieben in C#
    Sprache

    InformationsquelleAutor der Antwort V4Vendetta

  3. 3

    Delegierten.

    Den Aufruf des Delegaten ist viel langsamer als der Standard-Aufruf zu IComparable.CompareTo

    Update:

    Wenn Sie möchten, dass die gleiche (oder schließen), Geschwindigkeit, die Umsetzung der IComparer - Schnittstelle und übergeben, die an die sort-Methode.

    http://msdn.microsoft.com/en-us/library/bzw8611x

    InformationsquelleAutor der Antwort leppie

  4. 2

    Weil in Ihrer zweiten version hat es zum aufrufen von Ihr eine (anonyme) Funktion jedes mal ein vergleichen und dann zu rufen .CompareTo-innen, so dass Sie zwei indirections, in der Erwägung, dass andernfalls kann es verwenden build-in-Vergleiche (für primitive Typen).

    Grundsätzlich zahlen Sie für Funktionsaufruf-overhead, die ich Wette, die werden eliminiert, die für native primitive Typen, wenn Sie diese Arten von Operationen. Obwohl technisch möglich (denke ich), ich bezweifle, dass der Jitter ist in der Lage, vollständig inline-Sie in Ihrem zweiten Fall.

    InformationsquelleAutor der Antwort chrisaut

Schreibe einen Kommentar