Array.BinarySearch Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Wyszukuje jednowymiarowe posortowane Array dla wartości przy użyciu algorytmu wyszukiwania binarnego.

Przeciążenia

BinarySearch(Array, Object)	Wyszukuje całą tablicę posortowaną jednowymiarową dla określonego elementu przy użyciu IComparable interfejsu zaimplementowanego przez każdy element tablicy i określony obiekt.
BinarySearch(Array, Object, IComparer)	Wyszukuje całą tablicę posortowaną jednowymiarową dla wartości przy użyciu określonego IComparer interfejsu.
BinarySearch(Array, Int32, Int32, Object)	Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu IComparable interfejsu zaimplementowanego przez każdy element tablicy i przez określoną wartość.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu określonego IComparer interfejsu.
BinarySearch<T>(T[], T)	Wyszukuje całą tablicę posortowaną jednowymiarową dla określonego elementu przy użyciu IComparable<T> interfejsu ogólnego zaimplementowanego przez każdy element Array i przez określony obiekt.
BinarySearch<T>(T[], T, IComparer<T>)	Wyszukuje całą tablicę posortowaną jednowymiarową dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.
BinarySearch<T>(T[], Int32, Int32, T)	Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu IComparable<T> interfejsu ogólnego zaimplementowanego przez każdy element Array elementu i według określonej wartości.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.

BinarySearch(Array, Object)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje całą tablicę posortowaną jednowymiarową dla określonego elementu przy użyciu IComparable interfejsu zaimplementowanego przez każdy element tablicy i określony obiekt.

public:
 static int BinarySearch(Array ^ array, System::Object ^ value);

public static int BinarySearch (Array array, object value);

public static int BinarySearch (Array array, object? value);

static member BinarySearch : Array * obj -> int

Public Shared Function BinarySearch (array As Array, value As Object) As Integer

Parametry

array: Array

Posortowane jednowymiarowe Array do wyszukania.

value: Object

Obiekt, który trzeba wyszukać.

Zwraca

Int32

Indeks określonego w określonym valuearrayobiekcie , jeśli value zostanie znaleziony; w przeciwnym razie liczba ujemna. Jeśli value nie zostanie znaleziona i value jest mniejsza niż jeden lub więcej elementów w arrayelemecie , zwracana liczba ujemna jest bitowym uzupełnieniem indeksu pierwszego elementu, który jest większy niż value. Jeśli value nie zostanie znaleziona i value jest większa niż wszystkie elementy w arrayelemecie , zwracana liczba ujemna jest bitowym uzupełnieniem (indeks ostatniego elementu plus 1). Jeśli ta metoda jest wywoływana z niesortowaną arraywartością zwracaną może być nieprawidłowa, a liczba ujemna może zostać zwrócona, nawet jeśli value znajduje się w arrayobiekcie .

Wyjątki

ArgumentNullException

array to null.

RankException

Parametr array jest wielowymiarowy.

ArgumentException

valuejest typem, który nie jest zgodny z elementami .array

InvalidOperationException

value nie implementuje interfejsu IComparable , a wyszukiwanie napotyka element, który nie implementuje interfejsu IComparable .

Przykłady

W poniższym przykładzie kodu pokazano, jak użyć BinarySearch metody lokalizowania określonego obiektu w obiekcie Array.

Uwaga

Tablica jest tworzona z elementami w kolejności sortowania rosnącego. Metoda BinarySearch wymaga sortowania tablicy w kolejności rosnącej.

using namespace System;

public ref class SamplesArray
{
public:
    static void Main()
    {
        // Creates and initializes a new Array.
        Array^ myIntArray = Array::CreateInstance(Int32::typeid, 5);

        myIntArray->SetValue(8, 0);
        myIntArray->SetValue(2, 1);
        myIntArray->SetValue(6, 2);
        myIntArray->SetValue(3, 3);
        myIntArray->SetValue(7, 4);

        // Do the required sort first
        Array::Sort(myIntArray);

        // Displays the values of the Array.
        Console::WriteLine("The Int32 array contains the following:");
        PrintValues(myIntArray);

        // Locates a specific object that does not exist in the Array.
        Object^ myObjectOdd = 1;
        FindMyObject(myIntArray, myObjectOdd);

        // Locates an object that exists in the Array.
        Object^ myObjectEven = 6;
        FindMyObject(myIntArray, myObjectEven);
    }

    static void FindMyObject(Array^ myArr, Object^ myObject)
    {
        int myIndex = Array::BinarySearch(myArr, myObject);
        if (myIndex < 0)
        {
            Console::WriteLine("The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, ~myIndex);
        }
        else
        {
            Console::WriteLine("The object to search for ({0}) is at index {1}.", myObject, myIndex);
        }
    }

    static void PrintValues(Array^ myArr)
    {
        int i = 0;
        int cols = myArr->GetLength(myArr->Rank - 1);
        for each (Object^ o in myArr)
        {
            if ( i < cols )
            {
                i++;
            }
            else
            {
                Console::WriteLine();
                i = 1;
            }
            Console::Write("\t{0}", o);
        }
        Console::WriteLine();
    }
};

int main()
{
    SamplesArray::Main();
}
// This code produces the following output.
//
//The Int32 array contains the following:
//        2       3       6       7       8
//The object to search for (1) is not found. The next larger object is at index 0
//
//The object to search for (6) is at index 2.

open System

let printValues (myArray: Array) =
    let mutable i = 0
    let cols = myArray.GetLength(myArray.Rank - 1)
    for item in myArray do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1;
        printf $"\t{item}"
    printfn ""

let findMyObject (myArr: Array) (myObject: obj) =
    let myIndex = Array.BinarySearch(myArr, myObject)
    if myIndex < 0 then
        printfn $"The object to search for ({myObject}) is not found. The next larger object is at index {~~~myIndex}."
    else
        printfn $"The object to search for ({myObject}) is at index {myIndex}."

// Creates and initializes a new Array.
let myIntArray = [| 8; 2; 6; 3; 7 |]

// Do the required sort first
Array.Sort myIntArray

// Displays the values of the Array.
printfn "The int array contains the following:"
printValues myIntArray

// Locates a specific object that does not exist in the Array.
let myObjectOdd: obj = 1
findMyObject myIntArray myObjectOdd 

// Locates an object that exists in the Array.
let myObjectEven: obj = 6
findMyObject myIntArray myObjectEven
       
// This code produces the following output:
//     The int array contains the following:
//             2       3       6       7       8
//     The object to search for (1) is not found. The next larger object is at index 0.
//     The object to search for (6) is at index 2.

using System;

public class SamplesArray
{
    public static void Main()
    {
        // Creates and initializes a new Array.
        Array myIntArray = Array.CreateInstance(typeof(int), 5);

        myIntArray.SetValue(8, 0);
        myIntArray.SetValue(2, 1);
        myIntArray.SetValue(6, 2);
        myIntArray.SetValue(3, 3);
        myIntArray.SetValue(7, 4);

        // Do the required sort first
        Array.Sort(myIntArray);

        // Displays the values of the Array.
        Console.WriteLine( "The int array contains the following:" );
        PrintValues(myIntArray);

        // Locates a specific object that does not exist in the Array.
        object myObjectOdd = 1;
        FindMyObject( myIntArray, myObjectOdd );

        // Locates an object that exists in the Array.
        object myObjectEven = 6;
        FindMyObject(myIntArray, myObjectEven);
    }

    public static void FindMyObject(Array myArr, object myObject)
    {
        int myIndex=Array.BinarySearch(myArr, myObject);
        if (myIndex < 0)
        {
            Console.WriteLine("The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, ~myIndex );
        }
        else
        {
            Console.WriteLine("The object to search for ({0}) is at index {1}.", myObject, myIndex );
        }
    }

    public static void PrintValues(Array myArr)
    {
        int i = 0;
        int cols = myArr.GetLength(myArr.Rank - 1);
        foreach (object o in myArr)
        {
            if ( i < cols )
            {
                i++;
            }
            else
            {
                Console.WriteLine();
                i = 1;
            }
            Console.Write( "\t{0}", o);
        }
        Console.WriteLine();
    }
}
// This code produces the following output.
//
//The int array contains the following:
//        2       3       6       7       8
//The object to search for (1) is not found. The next larger object is at index 0
//
//The object to search for (6) is at index 2.

Public Class SamplesArray
    Public Shared Sub Main()
        ' Creates and initializes a new Array.
        Dim myIntArray As Array = Array.CreateInstance( GetType(Int32), 5 )

        myIntArray.SetValue( 8, 0 )
        myIntArray.SetValue( 2, 1 )
        myIntArray.SetValue( 6, 2 )
        myIntArray.SetValue( 3, 3 )
        myIntArray.SetValue( 7, 4 )

        ' Do the required sort first
        Array.Sort(myIntArray)

        ' Displays the values of the Array.
        Console.WriteLine("The Int32 array contains the following:")
        PrintValues(myIntArray)

        ' Locates a specific object that does not exist in the Array.
        Dim myObjectOdd As Object = 1
        FindMyObject(myIntArray, myObjectOdd)

        ' Locates an object that exists in the Array.
        Dim myObjectEven As Object = 6
        FindMyObject(myIntArray, myObjectEven)
    End Sub

    Public Shared Sub FindMyObject(myArr As Array, myObject As Object)
        Dim myIndex As Integer = Array.BinarySearch(myArr, myObject)
        If  myIndex < 0 Then
            Console.WriteLine("The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, Not(myIndex))
        Else
            Console.WriteLine("The object to search for ({0}) is at index {1}.", myObject, myIndex)
        End If
    End Sub

    Public Shared Sub PrintValues(myArr As Array)
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength( myArr.Rank - 1 )
        For Each o As Object In myArr
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write( vbTab + "{0}", o)
        Next o
        Console.WriteLine()
    End Sub
End Class
' This code produces the following output.
'
' The Int32 array contains the following:
'         2       3       6       7       8
' The object to search for (1) is not found. The next larger object is at index 0
'
' The object to search for (6) is at index 2.

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy sortować przed wywołaniem tej metody.

Jeśli wartość Array nie zawiera określonej wartości, metoda zwraca ujemną liczbę całkowitą. Możesz zastosować operator uzupełniania bitowego (~ w języku C#, Not w języku Visual Basic) do wyniku ujemnego w celu utworzenia indeksu. Jeśli ten indeks jest jednym większym niż górna granica tablicy, nie ma żadnych elementów większych niż value w tablicy. W przeciwnym razie jest to indeks pierwszego elementu, który jest większy niż value.

Albo value każdy element array musi zaimplementować IComparable interfejs, który jest używany do porównań. Elementy elementu array muszą być już posortowane w rosnącej wartości zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable . W przeciwnym razie wynik może być niepoprawny.

Uwaga

Jeślivalue interfejs nie zostanie zaimplementowany IComparable , elementy nie array zostaną przetestowane IComparable przed rozpoczęciem wyszukiwania. Wyjątek jest zgłaszany, jeśli wyszukiwanie napotka element, który nie implementuje IComparableelementu .

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z null nie generują wyjątku.

Uwaga

Dla każdego przetestowanego value elementu jest przekazywany do odpowiedniej IComparable implementacji, nawet jeśli value jest to null. Oznacza to, że implementacja IComparable określa, jak dany element porównuje się z wartością null.

Ta metoda jest operacją O(log n), gdzie n jest Length .array

Zobacz też

Dotyczy

BinarySearch(Array, Object, IComparer)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje całą tablicę posortowaną jednowymiarową dla wartości przy użyciu określonego IComparer interfejsu.

public:
 static int BinarySearch(Array ^ array, System::Object ^ value, System::Collections::IComparer ^ comparer);

public static int BinarySearch (Array array, object value, System.Collections.IComparer comparer);

public static int BinarySearch (Array array, object? value, System.Collections.IComparer? comparer);

static member BinarySearch : Array * obj * System.Collections.IComparer -> int

Public Shared Function BinarySearch (array As Array, value As Object, comparer As IComparer) As Integer

Parametry

array: Array

Posortowane jednowymiarowe Array do wyszukania.

value: Object

Obiekt, który trzeba wyszukać.

comparer: IComparer

Implementacja IComparer do użycia podczas porównywania elementów.

-lub-

null aby użyć implementacji IComparable każdego elementu.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

RankException

Parametr array jest wielowymiarowy.

ArgumentException

comparerto null, i value jest typem, który nie jest zgodny z elementami .array

InvalidOperationException

comparer to null, value nie implementuje interfejsu IComparable , a wyszukiwanie napotyka element, który nie implementuje interfejsu IComparable .

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy sortować przed wywołaniem tej metody.

Moduł porównujący dostosowuje sposób porównywania elementów. Można na przykład użyć elementu System.Collections.CaseInsensitiveComparer jako porównania do wykonywania wyszukiwania ciągów bez uwzględniania wielkości liter.

Jeśli comparer nie nulljest , elementy są array porównywane z określoną wartością przy użyciu określonej IComparer implementacji. Elementy elementu array muszą być już posortowane w wartości rosnącej zgodnie z kolejnością sortowania zdefiniowaną przez comparer; w przeciwnym razie wynik może być niepoprawny.

Jeślicomparer jest to null, porównanie odbywa się przy użyciu IComparable implementacji dostarczonej przez sam element lub przez określoną wartość. Elementy elementu array muszą być już posortowane w rosnącej wartości zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable . W przeciwnym razie wynik może być niepoprawny.

Uwaga

Jeśli comparer jest null i value nie implementuje interfejsu IComparable , elementy nie array są testowane przed IComparable rozpoczęciem wyszukiwania. Wyjątek jest zgłaszany, jeśli wyszukiwanie napotka element, który nie implementuje IComparableelementu .

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z null nie generują wyjątku.

Uwaga

Ta metoda jest operacją O(log n), gdzie n jest Length .array

Zobacz też

Dotyczy

BinarySearch(Array, Int32, Int32, Object)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu IComparable interfejsu zaimplementowanego przez każdy element tablicy i przez określoną wartość.

public:
 static int BinarySearch(Array ^ array, int index, int length, System::Object ^ value);

public static int BinarySearch (Array array, int index, int length, object value);

public static int BinarySearch (Array array, int index, int length, object? value);

static member BinarySearch : Array * int * int * obj -> int

Public Shared Function BinarySearch (array As Array, index As Integer, length As Integer, value As Object) As Integer

Parametry

array: Array

Posortowane jednowymiarowe Array do wyszukania.

index: Int32

Indeks początkowy zakresu wyszukiwania.

length: Int32

Długość zakresu wyszukiwania.

value: Object

Obiekt, który trzeba wyszukać.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

RankException

Parametr array jest wielowymiarowy.

ArgumentOutOfRangeException

indexjest mniejsza niż niższa granica .array

-lub-

Parametr length ma wartość niższą niż zero.

ArgumentException

index i length nie określają prawidłowego zakresu w arrayelemecie .

-lub-

valuejest typem, który nie jest zgodny z elementami .array

InvalidOperationException

value nie implementuje interfejsu IComparable , a wyszukiwanie napotyka element, który nie implementuje interfejsu IComparable .

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy sortować przed wywołaniem tej metody.

Uwaga

Jeśli value interfejs nie zostanie zaimplementowany IComparable , elementy nie array zostaną przetestowane IComparable przed rozpoczęciem wyszukiwania. Wyjątek jest zgłaszany, jeśli wyszukiwanie napotka element, który nie implementuje IComparableelementu .

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z null nie generują wyjątku.

Uwaga

Ta metoda to operacja O(log n), gdzie n to length.

Zobacz też

Dotyczy

BinarySearch(Array, Int32, Int32, Object, IComparer)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje zakres elementów w tablicy posortowanej jednowymiarowej dla wartości przy użyciu określonego IComparer interfejsu.

public:
 static int BinarySearch(Array ^ array, int index, int length, System::Object ^ value, System::Collections::IComparer ^ comparer);

public static int BinarySearch (Array array, int index, int length, object value, System.Collections.IComparer comparer);

public static int BinarySearch (Array array, int index, int length, object? value, System.Collections.IComparer? comparer);

static member BinarySearch : Array * int * int * obj * System.Collections.IComparer -> int

Public Shared Function BinarySearch (array As Array, index As Integer, length As Integer, value As Object, comparer As IComparer) As Integer

Parametry

array: Array

Posortowane jednowymiarowe Array do wyszukania.

index: Int32

Indeks początkowy zakresu wyszukiwania.

length: Int32

Długość zakresu wyszukiwania.

value: Object

Obiekt, który trzeba wyszukać.

comparer: IComparer

Implementacja IComparer do użycia podczas porównywania elementów.

-lub-

null aby użyć implementacji IComparable każdego elementu.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

RankException

Parametr array jest wielowymiarowy.

ArgumentOutOfRangeException

indexjest mniejsza niż niższa granica .array

-lub-

Parametr length ma wartość niższą niż zero.

ArgumentException

index i length nie określają prawidłowego zakresu w arrayelemecie .

-lub-

comparerto null, i value jest typem, który nie jest zgodny z elementami .array

InvalidOperationException

comparer to null, value nie implementuje interfejsu IComparable , a wyszukiwanie napotyka element, który nie implementuje interfejsu IComparable .

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy sortować przed wywołaniem tej metody.

Jeśli comparer jest to null, porównanie odbywa się przy użyciu IComparable implementacji dostarczonej przez sam element lub przez określoną wartość. Elementy elementu array muszą być już posortowane w rosnącej wartości zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable . W przeciwnym razie wynik może być niepoprawny.

Uwaga

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z parametrem null nie generują wyjątku w przypadku korzystania z polecenia IComparable.

Uwaga

Ta metoda to operacja O(log n), gdzie n to length.

Zobacz też

Dotyczy

BinarySearch<T>(T[], T)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje całą jednowymiarową tablicę posortowaną dla określonego elementu przy użyciu IComparable<T> interfejsu ogólnego zaimplementowanego przez każdy element Array obiektu i przez określony obiekt.

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, T value);

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

static member BinarySearch : 'T[] * 'T -> int

Public Shared Function BinarySearch(Of T) (array As T(), value As T) As Integer

Parametry typu

T

Typ elementów tablicy.

Parametry

array: T[]

Posortowane jednowymiarowe, zero oparte na Array wyszukiwaniu.

value: T

Obiekt, który trzeba wyszukać.

Zwraca

Int32

Indeks określony value w określonym arrayobiekcie , jeśli value zostanie znaleziony; w przeciwnym razie liczba ujemna. Jeśli value nie zostanie znaleziony i value jest mniejszy niż jeden lub więcej elementów w arrayelemecie , zwracana liczba ujemna jest bitowym uzupełnieniem indeksu pierwszego elementu, który jest większy niż value. Jeśli value nie zostanie znaleziony i value jest większy niż wszystkie elementy w arrayelemecie , zwracana liczba ujemna jest bitowym uzupełnieniem (indeks ostatniego elementu plus 1). Jeśli ta metoda jest wywoływana z niesortowaną arraywartością , wartość zwracana może być niepoprawna, a liczba ujemna może zostać zwrócona, nawet jeśli value istnieje w arrayelemecie .

Wyjątki

ArgumentNullException

array to null.

InvalidOperationException

T nie implementuje interfejsu IComparable<T> ogólnego.

Przykłady

Poniższy przykład kodu przedstawia Sort<T>(T[]) przeciążenie metody ogólnej i BinarySearch<T>(T[], T) przeciążenie metody ogólnej. Tablica ciągów jest tworzona w żadnej określonej kolejności.

Tablica jest wyświetlana, sortowana i ponownie wyświetlana. Tablice muszą być sortowane w celu użycia BinarySearch metody .

Uwaga

Wywołania Sort metod ogólnych i BinarySearch nie wyglądają inaczej niż wywołania do ich niegenerycznych odpowiedników, ponieważ Visual Basic, F#, C# i C++ wywnioskują typ parametru typu ogólnego z typu pierwszego argumentu. Jeśli używasz Ildasm.exe (IL Dezasembler) do zbadania Microsoft języka pośredniego (MSIL), można zobaczyć, że metody ogólne są wywoływane.

Przeciążenie BinarySearch<T>(T[], T) metody ogólnej jest następnie używane do wyszukiwania dwóch ciągów, jeden, który nie znajduje się w tablicy i jeden, który jest. Tablica i wartość BinarySearch zwracana metody są przekazywane do ShowWhere metody ogólnej ( showWhere funkcja w przykładzie języka F#), która wyświetla wartość indeksu, jeśli ciąg zostanie znaleziony, a w przeciwnym razie elementy, między którymi znajduje się ciąg wyszukiwania, gdyby znajdował się w tablicy. Indeks jest ujemny, jeśli ciąg nie znajduje się w tablicy, więc ShowWhere metoda przyjmuje bitowe uzupełnienie (operator ~ w języku C# i Visual C++, operator ~~~ w języku F#, Xor-1 w Visual Basic), aby uzyskać indeks pierwszego elementu na liście, który jest większy niż ciąg wyszukiwania.

using namespace System;
using namespace System::Collections::Generic;

generic<typename T> void ShowWhere(array<T>^ arr, 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 ", arr[index-1]);

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

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

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

    Console::WriteLine();
    for each(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);
}

/* 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.
 */

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.
 */

open System

let showWhere (array: 'a []) index =
    if index < 0 then
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        let index = ~~~index

        printf "Not found. Sorts between: "

        if index = 0 then
            printf "beginning of array and "
        else
            printf $"{array[index - 1]} and "

        if index = array.Length then
            printfn "end of array."
        else
            printfn $"{array[index]}."
    else
        printfn $"Found at index {index}."

let dinosaurs =
    [| "Pachycephalosaurus"
       "Amargasaurus"
       "Tyrannosaurus"
       "Mamenchisaurus"
       "Deinonychus"
       "Edmontosaurus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nSort"
Array.Sort dinosaurs

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nBinarySearch for 'Coelophysis':"
let index = Array.BinarySearch(dinosaurs, "Coelophysis")
showWhere dinosaurs index

printfn "\nBinarySearch for 'Tyrannosaurus':"
Array.BinarySearch(dinosaurs, "Tyrannosaurus")
|> showWhere dinosaurs


// 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.

Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis")
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus")
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

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

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' 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.

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy sortować przed wywołaniem tej metody.

Jeśli array nie zawiera określonej wartości, metoda zwraca ujemną liczbę całkowitą. Możesz zastosować operator uzupełniania bitowego (~ w języku C#, Not w języku Visual Basic) do wyniku ujemnego w celu utworzenia indeksu. Jeśli ten indeks jest równy rozmiarowi tablicy, nie ma żadnych elementów większych niż value w tablicy. W przeciwnym razie jest to indeks pierwszego elementu, który jest większy niż value.

T musi zaimplementować IComparable<T> interfejs ogólny, który jest używany do porównań. Elementy elementu array muszą być już posortowane w rosnącej wartości zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable<T> . W przeciwnym razie wynik może być niepoprawny.

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z null nie generują wyjątku.

Uwaga

Dla każdego przetestowanego value elementu jest przekazywany do odpowiedniej IComparable<T> implementacji, nawet jeśli value jest to null. Oznacza to, że implementacja IComparable<T> określa, jak dany element porównuje się z wartością null.

Ta metoda jest operacją O(log n), gdzie n jest Length .array

Zobacz też

Dotyczy

BinarySearch<T>(T[], T, IComparer<T>)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje całą jednowymiarową tablicę posortowaną dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, T value, System::Collections::Generic::IComparer<T> ^ comparer);

public static int BinarySearch<T> (T[] array, T value, System.Collections.Generic.IComparer<T> comparer);

public static int BinarySearch<T> (T[] array, T value, System.Collections.Generic.IComparer<T>? comparer);

static member BinarySearch : 'T[] * 'T * System.Collections.Generic.IComparer<'T> -> int

Public Shared Function BinarySearch(Of T) (array As T(), value As T, comparer As IComparer(Of T)) As Integer

Parametry typu

T

Typ elementów tablicy.

Parametry

array: T[]

Posortowane jednowymiarowe, zero Array oparte na wyszukiwaniu.

value: T

Obiekt, który trzeba wyszukać.

comparer: IComparer<T>

Implementacja IComparer<T> do użycia podczas porównywania elementów.

-lub-

null aby użyć implementacji IComparable<T> każdego elementu.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

ArgumentException

comparerto null, i value jest typem, który nie jest zgodny z elementami .array

InvalidOperationException

comparer to null, i T nie implementuje interfejsu IComparable<T> ogólnego

Przykłady

W poniższym przykładzie pokazano Sort<T>(T[], IComparer<T>) przeciążenie metody ogólnej i BinarySearch<T>(T[], T, IComparer<T>) przeciążenie metody ogólnej.

W przykładzie kodu zdefiniowano alternatywny moduł porównujący ciągów o nazwie ReverseCompare, który implementuje IComparer<string> interfejs ogólny (IComparer(Of String) w języku Visual Basic IComparer<String^> w języku Visual C++). Funkcja porównująca wywołuje metodę CompareTo(String) , odwracając kolejność współzarządzań, tak aby ciągi sortowane były w sposób wysoki do niski zamiast niskich do wysokich.

Tablica jest wyświetlana, sortowana i ponownie wyświetlana. Tablice muszą być sortowane w celu użycia BinarySearch metody .

Uwaga

Wywołania Sort<T>(T[], IComparer<T>) metod ogólnych i BinarySearch<T>(T[], T, IComparer<T>) nie wyglądają inaczej niż wywołania do ich niegenerycznych odpowiedników, ponieważ język Visual Basic, C# i C++ wywnioskują typ parametru typu ogólnego z typu pierwszego argumentu. Jeśli używasz Ildasm.exe (dezasembler IL) do zbadania Microsoft języka pośredniego (MSIL), możesz zobaczyć, że są wywoływane metody ogólne.

Przeciążenie BinarySearch<T>(T[], T, IComparer<T>) metody ogólnej jest następnie używane do wyszukiwania dwóch ciągów, jeden, który nie znajduje się w tablicy i jeden, który jest. Tablica i wartość BinarySearch<T>(T[], T, IComparer<T>) zwracana metody są przekazywane do ShowWhere metody ogólnej ( showWhere funkcji w przykładzie języka F#), która wyświetla wartość indeksu, jeśli ciąg zostanie znaleziony, a w przeciwnym razie elementy, między którymi znajduje się ciąg wyszukiwania, gdyby znajdowała się w tablicy. Indeks jest ujemny, jeśli ciąg nie jest n tablicy, więc ShowWhere metoda przyjmuje bitowe uzupełnienie (operator ~ w języku C# i Visual C++, operator ~~~ w języku F#, Xor -1 w Visual Basic), aby uzyskać indeks pierwszego elementu na liście, który jest większy niż ciąg wyszukiwania.

using namespace System;
using namespace System::Collections::Generic;

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

generic<typename T> void ShowWhere(array<T>^ arr, 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 ", arr[index-1]);

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

void main()
{
    array<String^>^ dinosaurs = {"Pachycephalosaurus", 
                                 "Amargasaurus", 
                                 "Tyrannosaurus", 
                                 "Mamenchisaurus", 
                                 "Deinonychus", 
                                 "Edmontosaurus"};

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    ReverseComparer^ rc = gcnew ReverseComparer();

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

    Console::WriteLine();
    for each(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);
}

/* 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.
 */

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.
 */

open System
open System.Collections.Generic

type ReverseComparer() =
    interface IComparer<string> with
        member _.Compare(x, y) =
            // Compare y and x in reverse order.
            y.CompareTo x

let showWhere (array: 'a []) index =
    if index < 0 then
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        let index = ~~~index

        printf "Not found. Sorts between: "

        if index = 0 then
            printf "beginning of array and "
        else
            printf $"{array[index - 1]} and "

        if index = array.Length then
            printfn "end of array."
        else
            printfn $"{array[index]}."
    else
        printfn $"Found at index {index}."

let dinosaurs =
    [| "Pachycephalosaurus"
       "Amargasaurus"
       "Tyrannosaurus"
       "Mamenchisaurus"
       "Deinonychus"
       "Edmontosaurus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

let rc = ReverseComparer()

printfn "\nSort"
Array.Sort(dinosaurs, rc)

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nBinarySearch for 'Coelophysis':"
Array.BinarySearch(dinosaurs, "Coelophysis", rc)
|> showWhere dinosaurs

printfn "\nBinarySearch for 'Tyrannosaurus':"
Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
|> showWhere dinosaurs


// 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.

Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs, rc)

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis", rc)
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

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

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' 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.

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy posortować przed wywołaniem tej metody.

Jeśli wartość Array nie zawiera określonej wartości, metoda zwraca ujemną liczbę całkowitą. Możesz zastosować operator uzupełniania bitowego (~ w języku C#, Not w Visual Basic) do wyniku ujemnego w celu wygenerowania indeksu. Jeśli ten indeks jest równy rozmiarowi tablicy, nie ma elementów większych niż value w tablicy. W przeciwnym razie jest to indeks pierwszego elementu, który jest większy niż value.

Moduł porównujący dostosowuje sposób porównywania elementów. Na przykład można użyć elementu jako porównującego System.Collections.CaseInsensitiveComparer , aby wykonać wyszukiwanie ciągów bez uwzględniania wielkości liter.

Jeśli comparer nie nulljest , elementy elementu są porównywane array z określoną wartością przy użyciu określonej IComparer<T> implementacji interfejsu ogólnego. Elementy elementu array muszą być już posortowane w wartości rosnącej zgodnie z kolejnością sortowania zdefiniowaną przez comparer. W przeciwnym razie wynik może być niepoprawny.

Jeśli comparer parametr ma nullwartość , porównanie odbywa się przy użyciu implementacji interfejsu ogólnego dostarczonego IComparable<T> przez Tprogram . Elementy elementu array muszą być już posortowane w wartości rosnącej zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable<T> . W przeciwnym razie wynik może być niepoprawny.

Uwaga

Jeśli comparer element jest null i value nie implementuje interfejsu IComparable<T> ogólnego, elementy array nie są testowane przed IComparable<T> rozpoczęciem wyszukiwania. Wyjątek jest zgłaszany, jeśli wyszukiwanie napotka element, który nie implementuje IComparable<T>elementu .

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z parametrem null nie generują wyjątku.

Uwaga

Dla każdego przetestowanego value elementu jest przekazywany do odpowiedniej IComparable<T> implementacji, nawet jeśli value jest to null. Oznacza to, że implementacja IComparable<T> określa, w jaki sposób dany element jest porównywany z elementem null.

Ta metoda jest operacją O(log ), gdzie n jest operacją Length .arrayn

Zobacz też

Dotyczy

BinarySearch<T>(T[], Int32, Int32, T)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje zakres elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu interfejsu IComparable<T> ogólnego zaimplementowanego przez każdy element Array i przez określoną wartość.

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, int index, int length, T value);

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

static member BinarySearch : 'T[] * int * int * 'T -> int

Public Shared Function BinarySearch(Of T) (array As T(), index As Integer, length As Integer, value As T) As Integer

Parametry typu

T

Typ elementów tablicy.

Parametry

array: T[]

Posortowane jednowymiarowe, zero Array oparte na wyszukiwaniu.

index: Int32

Indeks początkowy zakresu wyszukiwania.

length: Int32

Długość zakresu wyszukiwania.

value: T

Obiekt, który trzeba wyszukać.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

ArgumentOutOfRangeException

indexwartość jest mniejsza niż dolna granica .array

-lub-

Parametr length ma wartość niższą niż zero.

ArgumentException

index i length nie należy określać prawidłowego zakresu w pliku array.

-lub-

value jest typem, który nie jest zgodny z elementami elementu array.

InvalidOperationException

T nie implementuje interfejsu IComparable<T> ogólnego.

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy posortować przed wywołaniem tej metody.

Jeśli tablica nie zawiera określonej wartości, metoda zwraca ujemną liczbę całkowitą. Możesz zastosować operator uzupełniania bitowego (~ w języku C#, Not w Visual Basic) do wyniku ujemnego w celu wygenerowania indeksu. Jeśli ten indeks jest równy rozmiarowi tablicy, nie ma elementów większych niż value w tablicy. W przeciwnym razie jest to indeks pierwszego elementu, który jest większy niż value.

T musi implementować IComparable<T> interfejs ogólny, który jest używany do porównań. Elementy elementu array muszą być już posortowane w wartości rosnącej zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable<T> . W przeciwnym razie wynik może być niepoprawny.

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z parametrem null nie generują wyjątku.

Uwaga

Dla każdego przetestowanego value elementu jest przekazywany do odpowiedniej IComparable<T> implementacji, nawet jeśli value jest to null. Oznacza to, że implementacja IComparable<T> określa, w jaki sposób dany element jest porównywany z elementem null.

Ta metoda jest operacją O(log n), gdzie n to length.

Zobacz też

Dotyczy

BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Źródło:: Array.cs

Źródło:: Array.cs

Źródło:: Array.cs

Wyszukuje zakres elementów w jednowymiarowej tablicy posortowanej dla wartości przy użyciu określonego IComparer<T> interfejsu ogólnego.

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, int index, int length, T value, System::Collections::Generic::IComparer<T> ^ comparer);

public static int BinarySearch<T> (T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T> comparer);

public static int BinarySearch<T> (T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T>? comparer);

static member BinarySearch : 'T[] * int * int * 'T * System.Collections.Generic.IComparer<'T> -> int

Public Shared Function BinarySearch(Of T) (array As T(), index As Integer, length As Integer, value As T, comparer As IComparer(Of T)) As Integer

Parametry typu

T

Typ elementów tablicy.

Parametry

array: T[]

Posortowane jednowymiarowe, zero Array oparte na wyszukiwaniu.

index: Int32

Indeks początkowy zakresu wyszukiwania.

length: Int32

Długość zakresu wyszukiwania.

value: T

Obiekt, który trzeba wyszukać.

comparer: IComparer<T>

Implementacja IComparer<T> do użycia podczas porównywania elementów.

-lub-

null aby użyć implementacji IComparable<T> każdego elementu.

Zwraca

Int32

Wyjątki

ArgumentNullException

array to null.

ArgumentOutOfRangeException

indexwartość jest mniejsza niż dolna granica .array

-lub-

Parametr length ma wartość niższą niż zero.

ArgumentException

index i length nie należy określać prawidłowego zakresu w pliku array.

-lub-

comparerto null, i value jest typem, który nie jest zgodny z elementami .array

InvalidOperationException

comparer to null, i T nie implementuje interfejsu IComparable<T> ogólnego.

Uwagi

Ta metoda nie obsługuje wyszukiwania tablic zawierających indeksy ujemne. array należy posortować przed wywołaniem tej metody.

Jeśli comparer wartość to null, porównanie odbywa się przy użyciu implementacji interfejsu ogólnego podanego IComparable<T> dla typu T. Elementy elementu array muszą być już posortowane w wartości rosnącej zgodnie z kolejnością sortowania zdefiniowaną przez implementację IComparable<T> . W przeciwnym razie wynik może być niepoprawny.

Dozwolone są zduplikowane elementy. Jeśli element Array zawiera więcej niż jeden element równy value, metoda zwraca indeks tylko jednego z wystąpień, a niekoniecznie pierwszy.

null zawsze można porównać z dowolnym innym typem referencyjnym; dlatego porównania z parametrem null nie generują wyjątku w przypadku używania polecenia IComparable<T>.

Uwaga

Dla każdego przetestowanego value elementu jest przekazywany do odpowiedniej IComparable<T> implementacji, nawet jeśli value jest to null. Oznacza to, że implementacja IComparable<T> określa, w jaki sposób dany element jest porównywany z elementem null.

Ta metoda jest operacją O(log n), gdzie n to length.

Zobacz też

Dotyczy

Array.BinarySearch Metoda

Definicja

Przeciążenia

BinarySearch(Array, Object)

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

BinarySearch(Array, Object, IComparer)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

BinarySearch(Array, Int32, Int32, Object)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

BinarySearch(Array, Int32, Int32, Object, IComparer)

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

BinarySearch<T>(T[], T)

Parametry typu

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

BinarySearch<T>(T[], T, IComparer<T>)

Parametry typu

Parametry

Zwraca

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

BinarySearch<T>(T[], Int32, Int32, T)

Parametry typu

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Parametry typu

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

Opinia

Dodatkowe zasoby