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.BinarySearch<T> méthode (T[], T, IComparer<T>)

 

Recherche une valeur dans l’intégralité d’un tableau trié unidimensionnel, à l’aide de l’interface générique IComparer<T> spécifiée.

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

public static int BinarySearch<T>(
	T[] array,
	T value,
	IComparer<T> comparer
)

Paramètres

array
Type: T[]

Array de base zéro trié unidimensionnel à explorer.

value
Type: T

Objet à rechercher.

comparer
Type: System.Collections.Generic.IComparer<T>

Implémentation de IComparer<T> à utiliser pendant la comparaison d'éléments.

ou

null pour utiliser l’implémentation de IComparable<T> de chaque élément.

Valeur de retour

Type: System.Int32

Index de la value spécifiée dans l’array spécifié, si value est trouvé. Si value est introuvable et que value est inférieur à un ou plusieurs éléments dans array, le nombre négatif retourné est le complément de bits de l’index du premier élément supérieur à value. Si value est introuvable et que value est supérieur à tous les éléments de array, le nombre négatif retourné est le complément de bits de l’index du dernier élément plus 1. Si cette méthode est appelée avec un array non trié, la valeur de retour peut être incorrecte et un nombre négatif peut être retourné, même si value est présent dans array.

Paramètres de type

T

Type des éléments du tableau.

Exception Condition
ArgumentNullException

array a la valeur null.

ArgumentException

comparer a la valeur null et value est d’un type qui n’est pas compatible avec les éléments de array.

InvalidOperationException

comparer est null, et T n’implémente pas l’interface générique IComparable<T>.

Cette méthode ne prend pas en charge la recherche dans les tableaux qui contiennent des index négatives. arraydoivent être triées avant d’appeler cette méthode.

Si le Array ne contient pas la valeur spécifiée, la méthode retourne un entier négatif. Vous pouvez appliquer l’opérateur de complément de bits (~ en c#, Not en Visual Basic) au résultat négatif pour produire un index. Si cet index est égal à la taille du tableau, ne contient aucun élément supérieur à value dans le tableau. Sinon, c’est l’index du premier élément supérieur à value.

Le comparateur personnalise la façon dont les éléments sont comparés. Par exemple, vous pouvez utiliser un System.Collections.CaseInsensitiveComparer en tant que comparateur pour effectuer des recherches de chaîne pas la casse.

Si comparer n’est pas null, les éléments de array sont comparées à la valeur spécifiée à l’aide de la IComparer<T> implémentation d’interface générique. Les éléments de array doit déjà être trié par ordre croissant selon l’ordre de tri défini par comparer; sinon, le résultat peut être incorrect.

Si comparer est null, la comparaison est effectuée à l’aide de la IComparable<T> implémentation d’interface générique fournie par T. Les éléments de array doit déjà être trié par ordre croissant selon l’ordre de tri défini par le IComparable<T> implémentation ; sinon, le résultat peut être incorrect.

System_CAPS_noteRemarque

Si comparer est null et value n’implémente pas le IComparable<T> interface générique, les éléments de array ne sont pas testées pour IComparable<T> avant le début de la recherche. Une exception est levée si la recherche rencontre un élément qui n’implémente pas IComparable<T>.

Les éléments en double sont autorisés. Si le Array contient plusieurs éléments égal à value, la méthode retourne l’index d’une des occurrences uniquement et pas nécessairement le.

nullpeut toujours être comparé à n’importe quel autre type de référence. Par conséquent, les comparaisons avec null ne génèrent pas d’exception.

System_CAPS_noteRemarque

Pour chaque élément testé, value est passée à approprié IComparable<T> mise en œuvre, même si value est null. Autrement dit, le IComparable<T> implémentation détermine comment un élément donné est comparé à null.

Cette méthode est un O (journal n) opération, où n est la Length de array.

L’exemple suivant illustre la Sort<T>(T[], IComparer<T>) surcharge de méthode générique et le BinarySearch<T>(T[], T, IComparer<T>) surcharge de méthode générique.

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 faible à élevé.

Le tableau est affiché, trié et affiche de nouveau. Les tableaux doivent être triées pour pouvoir utiliser leBinarySearch<T> (méthode).

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.

Le BinarySearch<T>(T[], T, IComparer<T>) surcharge de méthode générique est ensuite utilisée pour rechercher des deux chaînes, qui n’est pas dans le tableau et l’autre qui est. Le tableau et la valeur de retour de la BinarySearch<T>(T[], T, IComparer<T>) méthode sont passés à la ShowWhere une méthode générique, qui affiche la valeur d’index si la chaîne est trouvée, sinon les éléments de la chaîne de recherche se situant entre s’il s’agissait du tableau. L’index est négatif si la chaîne n’est pas n tableau, donc la ShowWhereméthode accepte le complément de bits (le ~ opérateur en c# et Visual C++, Xor -1 en Visual Basic) pour obtenir l’index du premier élément dans la liste qui est supérieure à la chaîne de recherche.

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", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

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

        ReverseComparer rc = new ReverseComparer();

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

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */

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: