Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Array.Sort<T> méthode (T[], Int32, Int32)

 

Date de publication : novembre 2016

Trie les éléments d’une plage d’éléments d’un Array à l’aide de l’implémentation de l’interface générique IComparable<T> de chaque élément de Array.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)

public static void Sort<T>(
	T[] array,
	int index,
	int length
)

Paramètres

array
Type: T[]

Array de base zéro unidimensionnel à trier.

index
Type: System.Int32

Index de départ de la plage à trier.

length
Type: System.Int32

Nombre d'éléments à trier dans la plage.

Paramètres de type

T

Type des éléments du tableau.

Exception Condition
ArgumentNullException

array a la valeur null.

ArgumentOutOfRangeException

index est inférieur à la limite inférieure de array.

ou

length est inférieur à zéro.

ArgumentException

index et length ne spécifient pas une plage valide dans array.

InvalidOperationException

Un ou plusieurs éléments de array n’implémentent pas l’interface générique IComparable<T>.

Chaque élément dans la plage spécifiée d’éléments dans array doit implémenter le IComparable<T> interface générique afin de pouvoir faire des comparaisons avec tous les autres éléments de array.

Si l’ordre de tri n’est pas terminée avec succès, les résultats sont indéfinis.

Cette méthode utilise l’algorithme de tri approfondie (introsort) comme suit :

  • Si la taille de partition est inférieur à 16 éléments, il utilise un insertion sort algorithme.

  • Si le nombre de partitions est supérieure à 2 * journalN, où N est la plage du tableau d’entrée, il utilise un Heapsort algorithme.

  • Sinon, il utilise un Quicksort algorithme.

Cette implémentation effectue un tri instable ; Autrement dit, si deux éléments sont égaux, leur ordre n'est pas conservée. En revanche, un tri stable conserve l'ordre des éléments qui sont identiques.

Pour les tableaux sont triés à l’aide d’algorithmes Heapsort et trions rapidement, dans le pire des cas, cette méthode est un O (n journal n) opération, où n est length.

L’exemple de code suivant montre la Sort<T>(T[], Int32, Int32) surcharge de méthode générique et le Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) la surcharge de méthode générique pour trier une plage dans un tableau.

L’exemple de code définit un autre comparateur pour les chaînes nommées ReverseCompare, qui implémente le IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> dans Visual C++) interface générique. Le comparateur appelle la CompareTo(String) méthode, en inversant l’ordre des comparateurs afin que les chaînes triées de haut en bas au lieu de bas en haut.

L’exemple de code crée et affiche un tableau de noms de dinosaure, composé de trois herbivores suivis par trois carnivores (tyrannosaures, pour être précis). Le Sort<T>(T[], Int32, Int32) surcharge de méthode générique est utilisée pour trier les trois derniers éléments du tableau, qui sont ensuite affichées. Le Sort<TKey, TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) surcharge de méthode générique est utilisée avec ReverseCompare pour trier les trois derniers éléments dans l’ordre inverse. Dinosaures entièrement désordonnés sont affichent de nouveau.

System_CAPS_noteRemarque

Les appels à la Sort<T>(T[], IComparer<T>) et BinarySearch<T>(T[], T, IComparer<T>) les méthodes génériques ne pas rechercher les appels à leurs équivalents non génériques, car Visual Basic, c# et C++ déduisent le type du paramètre de type générique à partir du type du premier argument. Si vous utilisez le Ildasm.exe (IL Disassembler) pour examiner le langage intermédiaire Microsoft (MSIL), vous pouvez voir que les méthodes génériques sont appelées.

using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Mamenchisaurus", 
                              "Tarbosaurus",
                              "Tyrannosaurus", 
                              "Albertasaurus"};

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nSort(dinosaurs, 3, 3)");
        Array.Sort(dinosaurs, 3, 3);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort(dinosaurs, 3, 3, rc)");
        Array.Sort(dinosaurs, 3, 3, rc);

        Console.WriteLine();
        foreach( string dinosaur in dinosaurs )
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tarbosaurus
Tyrannosaurus
Albertasaurus

Sort(dinosaurs, 3, 3)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Albertasaurus
Tarbosaurus
Tyrannosaurus

Sort(dinosaurs, 3, 3, rc)

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Tyrannosaurus
Tarbosaurus
Albertasaurus
 */

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 2.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1
Retour au début
Afficher: