Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo List<T>.BinarySearch (T, IComparer<T>)

 

Data di pubblicazione: ottobre 2016

Cerca un elemento nell'intero List<T> ordinato usando l'operatore di confronto specificato e restituisce l'indice in base zero dell'elemento.

Spazio dei nomi:   System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

public int BinarySearch(
	T item,
	IComparer<T> comparer
)

Parametri

item
Type: T

Oggetto da individuare. Il valore può essere null per i tipi di riferimento.

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

Implementazione IComparer<T> da usare quando si confrontano gli elementi.

-oppure-

null per usare la proprietà Comparer<T>.Default dell'operatore di confronto predefinito.

Valore restituito

Type: System.Int32

Indice in base zero di item nell'oggetto List<T> ordinato, se item viene trovato; in caso contrario, un numero negativo che rappresenta il complemento bit per bit dell'indice dell'elemento successivo maggiore di item o, se non è disponibile alcun elemento maggiore, il complemento bit per bit di Count.

Exception Condition
InvalidOperationException

comparer è null e l'operatore di confronto predefinito Comparer<T>.Default non riesce a trovare l'implementazione dell'interfaccia generica IComparable<T> o l'interfaccia IComparable per il tipo T.

L'operatore di confronto consente di personalizzare la modalità di confronto di elementi. Ad esempio, è possibile utilizzare un CaseInsensitiveComparer istanza come operatore di confronto per eseguire le ricerche di stringhe tra maiuscole e minuscole.

Se comparer viene fornito, gli elementi del List<T> rispetto al valore specificato utilizzando l'oggetto specificato IComparer<T> implementazione.

Se comparer è null, l'operatore di confronto Comparer<T>.Default verifica se il tipo T implementa il IComparable<T> interfaccia generica e utilizza tale implementazione, se disponibile. In caso contrario, Comparer<T>.Default verifica se il tipo T implementa il IComparable interfaccia. Se tipo T non implementa l'interfaccia Comparer<T>.Default Genera InvalidOperationException.

Il List<T> deve essere già ordinati in base all'implementazione dell'operatore di confronto; in caso contrario, il risultato non è corretto.

Confronto tra null con qualsiasi riferimento di tipo è consentito e non genera un'eccezione quando si utilizza il IComparable<T> interfaccia generica. Durante l'ordinamento, null viene considerato minore rispetto a qualsiasi altro oggetto.

Se il List<T> contiene più di un elemento con lo stesso valore, il metodo restituisce solo una delle occorrenze e potrebbe essere una qualsiasi delle occorrenze, non necessariamente il primo argomento.

Se il List<T> non contiene il valore specificato, il metodo restituisce un numero intero negativo. È possibile applicare l'operazione di complemento bit per bit (~) per questo numero intero negativo per ottenere l'indice del primo elemento che è maggiore del valore di ricerca. Quando si inserisce il valore di List<T>, questo indice deve essere utilizzato come punto di inserimento per gestire l'ordinamento.

Questo metodo è un'operazione O(log n), dove n è il numero di elementi nell'intervallo.

Nell'esempio seguente viene illustrato il Sort(IComparer<T>) overload del metodo e BinarySearch(T, IComparer<T>) overload del metodo.

L'esempio definisce un operatore di confronto alternativo per le stringhe denominato DinoCompare, che implementa il IComparer<string> (IComparer(Of String) in Visual Basic IComparer<String^> in Visual C++) dell'interfaccia generica. L'operatore di confronto funziona nel modo seguente: in primo luogo, i termini di confronto vengono verificati i null, e un riferimento null viene considerato minore rispetto a un valore non null. In secondo luogo, vengono confrontate le lunghezze di stringa e la stringa più lunga è considerata maggiore. In terzo luogo, se le lunghezze sono uguali, viene utilizzato confronto tra stringhe normali.

Oggetto List<T> di stringhe viene creato e popolato con quattro stringhe, senza nessun ordine particolare. L'elenco viene visualizzato, ordinato utilizzando l'operatore di confronto alternativo e visualizzata nuovamente.

Il BinarySearch(T, IComparer<T>) overload del metodo viene quindi utilizzato per cercare le diverse stringhe sono non in elenco, utilizzando l'operatore di confronto alternativo. Il Insert metodo viene utilizzato per inserire le stringhe. Questi due metodi si trovano nella funzione denominata SearchAndInsert, insieme al codice per utilizzare il complemento bit per bit (il ~ operatore in c# e Visual C++, Xor -1 in Visual Basic) del numero negativo restituito da BinarySearch(T, IComparer<T>) e utilizzarlo come indice per l'inserimento della nuova stringa.

using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list, 
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

        int index = list.BinarySearch(insert, dc);

        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: