Array.BinarySearch Metode

Referensi

Definisi

Ruang nama:: System

Rakitan:: System.Runtime.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Mencari Array yang diurutkan satu dimensi untuk nilai, menggunakan algoritma pencarian biner.

Overload

BinarySearch(Array, Object)	Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka IComparable yang diimplementasikan oleh setiap elemen array dan oleh objek yang ditentukan.
BinarySearch(Array, Object, IComparer)	Mencari seluruh array yang diurutkan satu dimensi untuk nilai menggunakan antarmuka IComparer yang ditentukan.
BinarySearch(Array, Int32, Int32, Object)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka IComparable yang diterapkan oleh setiap elemen array dan berdasarkan nilai yang ditentukan.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka IComparer yang ditentukan.
BinarySearch<T>(T[], T)	Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka generik IComparable<T> yang diimplementasikan oleh setiap elemen Array dan oleh objek yang ditentukan.
BinarySearch<T>(T[], T, IComparer<T>)	Mencari seluruh array yang diurutkan satu dimensi untuk nilai menggunakan antarmuka generik IComparer<T> yang ditentukan.
BinarySearch<T>(T[], Int32, Int32, T)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka generik IComparable<T> yang diterapkan oleh setiap elemen Array dan berdasarkan nilai yang ditentukan.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka generik IComparer<T> yang ditentukan.

BinarySearch(Array, Object)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka IComparable yang diimplementasikan oleh setiap elemen array dan oleh objek yang ditentukan.

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

Parameter

array: Array

Array satu dimensi yang diurutkan untuk dicari.

value: Object

Objek yang akan dicari.

Mengembalikan

Int32

Indeks value yang ditentukan dalam arrayyang ditentukan, jika value ditemukan; jika tidak, angka negatif. Jika value tidak ditemukan dan value kurang dari satu atau beberapa elemen dalam array, angka negatif yang dikembalikan adalah pelengkap bitwise dari indeks elemen pertama yang lebih besar dari value. Jika value tidak ditemukan dan value lebih besar dari semua elemen dalam array, angka negatif yang dikembalikan adalah pelengkap bitwise (indeks elemen terakhir ditambah 1). Jika metode ini dipanggil dengan arrayyang tidak diurutkan , nilai yang dikembalikan dapat salah dan angka negatif dapat dikembalikan, bahkan jika value ada di array.

Pengecualian

ArgumentNullException

array null.

RankException

array multidirmani.

ArgumentException

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

value tidak mengimplementasikan antarmuka IComparable, dan pencarian menemukan elemen yang tidak mengimplementasikan antarmuka IComparable.

Contoh

Contoh kode berikut menunjukkan cara menggunakan BinarySearch untuk menemukan objek tertentu dalam Array.

Nota

Array dibuat dengan elemennya dalam urutan urutan naik. Metode BinarySearch mengharuskan array diurutkan dalam urutan naik.

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.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika Array tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not di Visual Basic) ke hasil negatif untuk menghasilkan indeks. Jika indeks ini lebih besar dari batas atas array, tidak ada elemen yang lebih besar dari value dalam array. Jika tidak, ini adalah indeks elemen pertama yang lebih besar dari value.

Baik value atau setiap elemen array harus mengimplementasikan antarmuka IComparable, yang digunakan untuk perbandingan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable; jika tidak, hasilnya mungkin salah.

Nota

Jikavalue tidak menerapkan antarmuka IComparable, elemen array tidak diuji untuk IComparable sebelum pencarian dimulai. Pengecualian dilemparkan jika pencarian menemukan elemen yang tidak menerapkan IComparable.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Untuk setiap elemen yang diuji, value diteruskan ke implementasi IComparable yang sesuai, bahkan jika valuenull. Artinya, implementasi IComparable menentukan bagaimana elemen tertentu dibandingkan dengan null.

Metode ini adalah operasi O(log n), di mana n adalah Lengtharray.

Lihat juga

Berlaku untuk

BinarySearch(Array, Object, IComparer)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk nilai menggunakan antarmuka IComparer yang ditentukan.

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

Parameter

array: Array

Array satu dimensi yang diurutkan untuk dicari.

value: Object

Objek yang akan dicari.

comparer: IComparer

Implementasi IComparer digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan implementasi IComparable dari setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

RankException

array multidirmani.

ArgumentException

comparer null, dan value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

comparer null, value tidak mengimplementasikan antarmuka IComparable, dan pencarian menemukan elemen yang tidak mengimplementasikan antarmuka IComparable.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Pembanding menyesuaikan bagaimana elemen dibandingkan. Misalnya, Anda dapat menggunakan System.Collections.CaseInsensitiveComparer sebagai pembanding untuk melakukan pencarian string yang tidak peka huruf besar/kecil.

Jika comparer tidak null, elemen array dibandingkan dengan nilai yang ditentukan menggunakan implementasi IComparer yang ditentukan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh comparer; jika tidak, hasilnya mungkin salah.

Jikacomparernull, perbandingan dilakukan menggunakan implementasi IComparable yang disediakan oleh elemen itu sendiri atau oleh nilai yang ditentukan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable; jika tidak, hasilnya mungkin salah.

Nota

Jika comparernull dan value tidak menerapkan antarmuka IComparable, elemen array tidak diuji untuk IComparable sebelum pencarian dimulai. Pengecualian dilemparkan jika pencarian menemukan elemen yang tidak menerapkan IComparable.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Metode ini adalah operasi O(log n), di mana n adalah Lengtharray.

Lihat juga

Berlaku untuk

BinarySearch(Array, Int32, Int32, Object)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka IComparable yang diterapkan oleh setiap elemen array dan berdasarkan nilai yang ditentukan.

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

Parameter

array: Array

Array satu dimensi yang diurutkan untuk dicari.

index: Int32

Indeks awal rentang yang akan dicari.

length: Int32

Panjang rentang yang akan dicari.

value: Object

Objek yang akan dicari.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

RankException

array multidirmani.

ArgumentOutOfRangeException

index kurang dari batas bawah array.

-atau-

length kurang dari nol.

ArgumentException

index dan length tidak menentukan rentang yang valid dalam array.

-atau-

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

value tidak mengimplementasikan antarmuka IComparable, dan pencarian menemukan elemen yang tidak mengimplementasikan antarmuka IComparable.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Nota

Jika value tidak menerapkan antarmuka IComparable, elemen array tidak diuji untuk IComparable sebelum pencarian dimulai. Pengecualian dilemparkan jika pencarian menemukan elemen yang tidak menerapkan IComparable.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Metode ini adalah operasi O(log n), di mana nlength.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka IComparer yang ditentukan.

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

Parameter

array: Array

Array satu dimensi yang diurutkan untuk dicari.

index: Int32

Indeks awal rentang yang akan dicari.

length: Int32

Panjang rentang yang akan dicari.

value: Object

Objek yang akan dicari.

comparer: IComparer

Implementasi IComparer digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan implementasi IComparable dari setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

RankException

array multidirmani.

ArgumentOutOfRangeException

index kurang dari batas bawah array.

-atau-

length kurang dari nol.

ArgumentException

index dan length tidak menentukan rentang yang valid dalam array.

-atau-

comparer null, dan value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

comparer null, value tidak mengimplementasikan antarmuka IComparable, dan pencarian menemukan elemen yang tidak mengimplementasikan antarmuka IComparable.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika comparernull, perbandingan dilakukan menggunakan implementasi IComparable yang disediakan oleh elemen itu sendiri atau oleh nilai yang ditentukan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable; jika tidak, hasilnya mungkin salah.

Nota

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian saat menggunakan IComparable.

Nota

Metode ini adalah operasi O(log n), di mana nlength.

Lihat juga

Berlaku untuk

BinarySearch<T>(T[], T)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka generik IComparable<T> yang diimplementasikan oleh setiap elemen Array dan oleh objek yang ditentukan.

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

Jenis parameter

T

Jenis elemen array.

Parameter

array: T[]

Array berbasis nol satu dimensi yang diurutkan untuk dicari.

value: T

Objek yang akan dicari.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

InvalidOperationException

T tidak mengimplementasikan antarmuka generik IComparable<T>.

Contoh

Contoh kode berikut menunjukkan kelebihan metode generik Sort<T>(T[]) dan kelebihan metode generik BinarySearch<T>(T[], T). Array string dibuat, tanpa urutan tertentu.

Array ditampilkan, diurutkan, dan ditampilkan lagi. Array harus diurutkan untuk menggunakan metode BinarySearch.

Nota

Panggilan ke metode generik Sort dan BinarySearch tidak terlihat berbeda dari panggilan ke rekan nongenerik mereka, karena Visual Basic, F#, C#, dan C++ menyimpulkan jenis parameter jenis generik dari jenis argumen pertama. Jika Anda menggunakan Ildasm.exe (Il Disassembler) untuk memeriksa bahasa perantara Microsoft (MSIL), Anda dapat melihat bahwa metode generik sedang dipanggil.

Metode BinarySearch<T>(T[], T) generik kelebihan beban kemudian digunakan untuk mencari dua string, satu yang tidak ada dalam array dan yang ada. Array dan nilai pengembalian metode BinarySearch diteruskan ke metode generik ShowWhere (fungsi showWhere dalam contoh F#), yang menampilkan nilai indeks jika string ditemukan, dan jika tidak, elemen string pencarian akan berada di antara jika ada dalam array. Indeks negatif jika string tidak ada dalam array, sehingga metode ShowWhere mengambil pelengkap bitwise (operator ~ di C# dan Visual C++, operator ~~~ di F#, Xor-1 di Visual Basic) untuk mendapatkan indeks elemen pertama dalam daftar yang lebih besar dari string pencarian.

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.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika array tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not di Visual Basic) ke hasil negatif untuk menghasilkan indeks. Jika indeks ini sama dengan ukuran array, tidak ada elemen yang lebih besar dari value dalam array. Jika tidak, ini adalah indeks elemen pertama yang lebih besar dari value.

T harus menerapkan antarmuka generik IComparable<T>, yang digunakan untuk perbandingan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable<T>; jika tidak, hasilnya mungkin salah.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Untuk setiap elemen yang diuji, value diteruskan ke implementasi IComparable<T> yang sesuai, bahkan jika valuenull. Artinya, implementasi IComparable<T> menentukan bagaimana elemen tertentu dibandingkan dengan null.

Metode ini adalah operasi O(log n), di mana n adalah Lengtharray.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk nilai menggunakan antarmuka generik IComparer<T> yang ditentukan.

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

Jenis parameter

T

Jenis elemen array.

Parameter

array: T[]

Array berbasis nol satu dimensi yang diurutkan untuk dicari.

value: T

Objek yang akan dicari.

comparer: IComparer<T>

Implementasi IComparer<T> digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan implementasi IComparable<T> dari setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

ArgumentException

comparer null, dan value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

comparer null, dan T tidak mengimplementasikan antarmuka generik IComparable<T>

Contoh

Contoh berikut menunjukkan kelebihan metode generik Sort<T>(T[], IComparer<T>) dan kelebihan metode generik BinarySearch<T>(T[], T, IComparer<T>).

Contoh kode mendefinisikan perbandingan alternatif untuk string, bernama ReverseCompare, yang mengimplementasikan antarmuka generik IComparer<string> (IComparer(Of String) di Visual Basic, IComparer<String^> di Visual C++). Pembanding memanggil metode CompareTo(String), membalikkan urutan perbandingan sehingga string mengurutkan tinggi ke rendah alih-alih rendah ke tinggi.

Array ditampilkan, diurutkan, dan ditampilkan lagi. Array harus diurutkan untuk menggunakan metode BinarySearch.

Nota

Panggilan ke metode generik Sort<T>(T[], IComparer<T>) dan BinarySearch<T>(T[], T, IComparer<T>) tidak terlihat berbeda dari panggilan ke rekan nongenerik mereka, karena Visual Basic, C#, dan C++ menyimpulkan jenis parameter jenis generik dari jenis argumen pertama. Jika Anda menggunakan Ildasm.exe (Il Disassembler) untuk memeriksa bahasa perantara Microsoft (MSIL), Anda dapat melihat bahwa metode generik sedang dipanggil.

Metode BinarySearch<T>(T[], T, IComparer<T>) generik kelebihan beban kemudian digunakan untuk mencari dua string, satu yang tidak ada dalam array dan yang ada. Array dan nilai pengembalian metode BinarySearch<T>(T[], T, IComparer<T>) diteruskan ke metode generik ShowWhere (fungsi showWhere dalam contoh F#), yang menampilkan nilai indeks jika string ditemukan, dan jika tidak, elemen string pencarian akan berada di antara jika ada dalam array. Indeks negatif jika string tidak n array, sehingga metode ShowWhere mengambil pelengkap bitwise (operator ~ di C# dan Visual C++, operator ~~~ di F#, Xor -1 di Visual Basic) untuk mendapatkan indeks elemen pertama dalam daftar yang lebih besar dari string pencarian.

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.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika Array tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not di Visual Basic) ke hasil negatif untuk menghasilkan indeks. Jika indeks ini sama dengan ukuran array, tidak ada elemen yang lebih besar dari value dalam array. Jika tidak, ini adalah indeks elemen pertama yang lebih besar dari value.

Jika comparer tidak null, elemen array dibandingkan dengan nilai yang ditentukan menggunakan implementasi antarmuka generik IComparer<T> yang ditentukan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh comparer; jika tidak, hasilnya mungkin salah.

Jika comparernull, perbandingan dilakukan menggunakan implementasi antarmuka generik IComparable<T> yang disediakan oleh T. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable<T>; jika tidak, hasilnya mungkin salah.

Nota

Jika comparernull dan value tidak mengimplementasikan antarmuka generik IComparable<T>, elemen array tidak diuji untuk IComparable<T> sebelum pencarian dimulai. Pengecualian dilemparkan jika pencarian menemukan elemen yang tidak menerapkan IComparable<T>.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Metode ini adalah operasi O(log n), di mana n adalah Lengtharray.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka generik IComparable<T> yang diterapkan oleh setiap elemen Array dan berdasarkan nilai yang ditentukan.

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

Jenis parameter

T

Jenis elemen array.

Parameter

array: T[]

Array berbasis nol satu dimensi yang diurutkan untuk dicari.

index: Int32

Indeks awal rentang yang akan dicari.

length: Int32

Panjang rentang yang akan dicari.

value: T

Objek yang akan dicari.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

ArgumentOutOfRangeException

index kurang dari batas bawah array.

-atau-

length kurang dari nol.

ArgumentException

index dan length tidak menentukan rentang yang valid dalam array.

-atau-

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

T tidak mengimplementasikan antarmuka generik IComparable<T>.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika array tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not di Visual Basic) ke hasil negatif untuk menghasilkan indeks. Jika indeks ini sama dengan ukuran array, tidak ada elemen yang lebih besar dari value dalam array. Jika tidak, ini adalah indeks elemen pertama yang lebih besar dari value.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian.

Nota

Metode ini adalah operasi O(log n), di mana nlength.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka generik IComparer<T> yang ditentukan.

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

Jenis parameter

T

Jenis elemen array.

Parameter

array: T[]

Array berbasis nol satu dimensi yang diurutkan untuk dicari.

index: Int32

Indeks awal rentang yang akan dicari.

length: Int32

Panjang rentang yang akan dicari.

value: T

Objek yang akan dicari.

comparer: IComparer<T>

Implementasi IComparer<T> digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan implementasi IComparable<T> dari setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array null.

ArgumentOutOfRangeException

index kurang dari batas bawah array.

-atau-

length kurang dari nol.

ArgumentException

index dan length tidak menentukan rentang yang valid dalam array.

-atau-

comparer null, dan value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

comparer null, dan T tidak mengimplementasikan antarmuka generik IComparable<T>.

Keterangan

Metode ini tidak mendukung pencarian array yang berisi indeks negatif. array harus diurutkan sebelum memanggil metode ini.

Jika comparernull, perbandingan dilakukan menggunakan implementasi antarmuka generik IComparable<T> yang disediakan untuk jenis T. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh implementasi IComparable<T>; jika tidak, hasilnya mungkin salah.

Elemen duplikat diizinkan. Jika Array berisi lebih dari satu elemen yang sama dengan value, metode mengembalikan indeks hanya salah satu kemunculan, dan belum tentu yang pertama.

null selalu dapat dibandingkan dengan jenis referensi lainnya; oleh karena itu, perbandingan dengan null tidak menghasilkan pengecualian saat menggunakan IComparable<T>.

Nota

Metode ini adalah operasi O(log n), di mana nlength.

Lihat juga

Berlaku untuk

Bagikan melalui

Array.BinarySearch Metode

Definisi

Overload

BinarySearch(Array, Object)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

BinarySearch(Array, Object, IComparer)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

BinarySearch(Array, Int32, Int32, Object)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

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

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

BinarySearch<T>(T[], T)

Jenis parameter

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

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

Jenis parameter

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

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

Jenis parameter

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

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

Jenis parameter

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

Sumber Daya Tambahan: