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 Array.BinarySearch<T>(T[], T)

 

Effettua una ricerca in un'intera matrice unidimensionale ordinata per un elemento specifico, usando l'interfaccia generica IComparable<T> implementata da ogni elemento di Array e dall'oggetto specificato.

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

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

Parametri

array
Type: T[]

Oggetto Array ordinato unidimensionale in base zero da cercare.

value
Type: T

Oggetto da cercare.

Valore restituito

Type: System.Int32

Indice del parametro value specificato nel parametro array specificato, se viene trovato value; in caso contrario, un numero negativo. Se value non viene trovato e value è minore di uno o più elementi presenti in array, il numero negativo restituito corrisponde al complemento bit per bit dell'indice del primo elemento maggiore di value. Se value non viene trovato e value è maggiore di tutti gli elementi in array, il numero negativo restituito corrisponde al complemento bit per bit dell'indice dell'ultimo elemento più 1. Se questo metodo viene chiamato con un oggetto array non ordinato, il valore restituito potrebbe non essere corretto e potrebbe essere restituito un numero negativo, anche se value è presente in array.

Parametri tipo

T

Tipo degli elementi della matrice.

Exception Condition
ArgumentNullException

array è null.

InvalidOperationException

T non implementa l'interfaccia generica IComparable<T>.

Questo metodo non supporta la ricerca di matrici che contengono indici negativi. arraydevono essere ordinati prima di chiamare questo metodo.

Se array non contiene il valore specificato, il metodo restituisce un numero intero negativo. È possibile applicare l'operatore di complemento bit per bit (~ in c#, Not in Visual Basic) per il risultato per produrre un indice negativo. Se l'indice è uguale alla dimensione della matrice, non sono presenti elementi maggiore value nella matrice. In caso contrario, è l'indice del primo elemento maggiore di value.

Tè necessario implementare la IComparable<T> interfaccia generica, che viene utilizzato per i confronti. Gli elementi di array già devono essere ordinati in ordine crescente in base all'ordinamento definito per il IComparable<T> implementazione; in caso contrario, il risultato potrebbe essere errato.

Sono consentiti elementi duplicati. Se il Array contiene più di un elemento uguale a value, il metodo restituisce l'indice solo uno dei casi e non necessariamente il primo.

nullpuò sempre essere confrontato con altri tipi riferimento. di conseguenza, i confronti con null non generano un'eccezione.

System_CAPS_noteNota

Per ogni elemento verificato, value viene passato a appropriato IComparable<T> implementazione, anche se value è null. Vale a dire il IComparable<T> implementazione determina il modo in cui un determinato elemento Confronta a null.

Questo metodo è un'operazione O (log n) operazione, in cui n è il Length di array.

L'esempio di codice seguente illustra la Sort<T>(T[]) overload del metodo generico e BinarySearch<T>(T[], T) overload del metodo generico. Viene creata una matrice di stringhe, in nessun ordine particolare.

La matrice è visualizzata, ordinata e visualizzata di nuovo. Le matrici devono essere ordinate per utilizzare il BinarySearch<T> metodo.

System_CAPS_noteNota

Le chiamate al Sort<T> e BinarySearch<T> metodi generici non presenta alcuna differenza dalle chiamate alle controparti non generiche, perché Visual Basic, c# e C++ dedurre il tipo di parametro di tipo generico dal tipo del primo argomento. Se si utilizza il Ildasm.exe (IL Disassembler) per esaminare il Microsoft intermediate language (MSIL), si noterà che vengono chiamati i metodi generici.

Il BinarySearch<T>(T[], T) overload del metodo generico viene quindi utilizzato per eseguire la ricerca di due stringhe, uno che non si trova la matrice e uno che. La matrice e il valore restituito del BinarySearch<T> metodo vengono passati al ShowWhere metodo generico, che viene visualizzato il valore di indice se la stringa viene trovata, e in caso contrario gli elementi della stringa di ricerca sarebbe compresa se fosse nella matrice. L'indice è negativo se la stringa non è incluso nella matrice, pertanto la ShowWhere metodo accetta il complemento bit per bit (il ~ (operatore) in c# e Visual C++, Xor-1 in Visual Basic) per ottenere l'indice del primo elemento nell'elenco di dimensioni maggiore rispetto alla stringa di ricerca.

using System;
using System.Collections.Generic;

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);
        }

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

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

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

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus");
        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

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

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

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

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: