Array.BinarySearch Metode

Definisi

Ruang nama:: System

Rakitan:: mscorlib.dll, System.Runtime.dll

Rakitan:: netstandard.dll, System.Runtime.dll

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 nilai yang diurutkan Array satu dimensi, menggunakan algoritma pencarian biner.

Overload

Nama	Deskripsi
BinarySearch(Array, Object)	Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka yang IComparable 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 yang ditentukan IComparer .
BinarySearch(Array, Int32, Int32, Object)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka yang IComparable diimplementasikan 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 yang ditentukan IComparer .
BinarySearch<T>(T[], T)	Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan IComparable<T> antarmuka generik 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 yang ditentukan IComparer<T> .
BinarySearch<T>(T[], Int32, Int32, T)	Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan IComparable<T> antarmuka generik yang diimplementasikan 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 yang ditentukan IComparer<T> .

BinarySearch(Array, Object)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan antarmuka yang IComparable 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

Satu dimensi Array yang diurutkan untuk dicari.

value: Object

Objek yang akan dicari.

Mengembalikan

Int32

Indeks yang ditentukan value dalam array, 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 non-diurutkan array, nilai yang dikembalikan dapat salah dan angka negatif dapat dikembalikan, bahkan jika value ada di array.

Pengecualian

ArgumentNullException

array adalah null.

RankException

array bersifat multidaya.

ArgumentException

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

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

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 ini mengharuskan array diurutkan dalam urutan naik.

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.

Array Jika tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not dalam 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 IComparable antarmuka, yang digunakan untuk perbandingan. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh IComparable implementasi; jika tidak, hasilnya mungkin salah.

Nota

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

Elemen duplikat diizinkan. Array Jika 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 yang sesuai IComparable , bahkan jika value adalah null. Artinya, IComparable implementasi menentukan bagaimana elemen tertentu dibandingkan dengan null.

Metode ini adalah operasi O(log n), di mana n adalah Length dari array.

Lihat juga

Berlaku untuk

BinarySearch(Array, Object, IComparer)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

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

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

Satu dimensi Array yang diurutkan untuk dicari.

value: Object

Objek yang akan dicari.

comparer: IComparer

Implementasi IComparer yang digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan IComparable implementasi setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array adalah null.

RankException

array bersifat multidaya.

ArgumentException

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

InvalidOperationException

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

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 , elemen array dibandingkan dengan nilai yang ditentukan menggunakan implementasi yang ditentukan IComparernull. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh comparer; jika tidak, hasilnya mungkin salah.

Jikacomparer adalah null, perbandingan dilakukan menggunakan IComparable implementasi 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 IComparable implementasi; jika tidak, hasilnya mungkin salah.

Nota

Jika comparer adalah null dan value tidak menerapkan IComparable antarmuka, elemen array tidak diuji IComparable sebelum pencarian dimulai. Pengecualian dilemparkan jika pencarian menemukan elemen yang tidak mengimplementasikan IComparable.

Elemen duplikat diizinkan. Array Jika 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 Length dari array.

Lihat juga

Berlaku untuk

BinarySearch(Array, Int32, Int32, Object)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan antarmuka yang IComparable diimplementasikan 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

Satu dimensi Array 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 adalah null.

RankException

array bersifat multidaya.

ArgumentOutOfRangeException

index kurang dari batas arraybawah .

-atau-

length kurang dari nol.

ArgumentException

index dan length jangan tentukan rentang yang valid di array.

-atau-

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

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

Keterangan

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

Nota

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

Elemen duplikat diizinkan. Array Jika 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 length.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

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

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

Satu dimensi Array 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 yang digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan IComparable implementasi setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array adalah null.

RankException

array bersifat multidaya.

ArgumentOutOfRangeException

index kurang dari batas arraybawah .

-atau-

length kurang dari nol.

ArgumentException

index dan length jangan tentukan rentang yang valid di array.

-atau-

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

InvalidOperationException

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

Keterangan

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

Jika comparer adalah null, perbandingan dilakukan menggunakan IComparable implementasi 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 IComparable implementasi; jika tidak, hasilnya mungkin salah.

Nota

Elemen duplikat diizinkan. Array Jika 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 n adalah length.

Lihat juga

Berlaku untuk

BinarySearch<T>(T[], T)

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari seluruh array yang diurutkan satu dimensi untuk elemen tertentu, menggunakan IComparable<T> antarmuka generik 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[]

Berbasis satu dimensi dan nol Array yang diurutkan untuk dicari.

value: T

Objek yang akan dicari.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array adalah null.

InvalidOperationException

T tidak mengimplementasikan IComparable<T> antarmuka generik.

Contoh

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

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

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 (MSIL) Microsoft, 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 BinarySearch pengembalian metode diteruskan ke ShowWhere metode generik ( showWhere fungsi dalam contoh F#), yang menampilkan nilai indeks jika string ditemukan, dan jika tidak, elemen string pencarian akan berada di antara jika berada dalam array. Indeks negatif jika string tidak berada dalam array, sehingga metode ShowWhere mengambil pelengkap bitwise (operator ~ di C#, operator ~~~ di F#, Xor-1 di Visual Basic) untuk mendapatkan indeks elemen pertama dalam daftar yang lebih besar dari string pencarian.

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

Elemen duplikat diizinkan. Array Jika 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 yang sesuai IComparable<T> , bahkan jika value adalah null. Artinya, IComparable<T> implementasi menentukan bagaimana elemen tertentu dibandingkan dengan null.

Metode ini adalah operasi O(log n), di mana n adalah Length dari array.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

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

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[]

Berbasis satu dimensi dan nol Array yang diurutkan untuk dicari.

value: T

Objek yang akan dicari.

comparer: IComparer<T>

Implementasi IComparer<T> yang digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan IComparable<T> implementasi setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array adalah null.

ArgumentException

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

InvalidOperationException

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

Contoh

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

Contoh kode mendefinisikan perbandingan alternatif untuk string, bernama ReverseCompare, yang mengimplementasikan antarmuka generik IComparer<string> (IComparer(Of String) di Visual Basic). Pembanding memanggil CompareTo(String) metode , 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 BinarySearch metode .

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 (MSIL) Microsoft, 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 BinarySearch<T>(T[], T, IComparer<T>) pengembalian metode diteruskan ke ShowWhere metode generik ( showWhere fungsi dalam contoh F#), yang menampilkan nilai indeks jika string ditemukan, dan jika tidak, elemen string pencarian akan berada di antara jika berada dalam array. Indeks negatif jika string tidak n array, sehingga metode ShowWhere mengambil pelengkap bitwise (operator ~ di C#, operator ~~~ di F#, Xor -1 di Visual Basic) untuk mendapatkan indeks elemen pertama dalam daftar yang lebih besar dari string pencarian.

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.

Array Jika tidak berisi nilai yang ditentukan, metode mengembalikan bilangan bulat negatif. Anda dapat menerapkan operator pelengkap bitwise (~ dalam C#, Not dalam 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 , elemen array dibandingkan dengan nilai yang ditentukan menggunakan implementasi antarmuka generik yang ditentukan IComparer<T>null. Elemen array harus sudah diurutkan dalam nilai yang meningkat sesuai dengan urutan pengurutan yang ditentukan oleh comparer; jika tidak, hasilnya mungkin salah.

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

Nota

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

Elemen duplikat diizinkan. Array Jika 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 Length dari array.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Mencari rentang elemen dalam array yang diurutkan satu dimensi untuk nilai, menggunakan IComparable<T> antarmuka generik yang diimplementasikan 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[]

Berbasis satu dimensi dan nol Array 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 adalah null.

ArgumentOutOfRangeException

index kurang dari batas arraybawah .

-atau-

length kurang dari nol.

ArgumentException

index dan length jangan tentukan rentang yang valid di array.

-atau-

value adalah jenis yang tidak kompatibel dengan elemen array.

InvalidOperationException

T tidak mengimplementasikan IComparable<T> antarmuka generik.

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 dalam 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. Array Jika 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 length.

Lihat juga

Berlaku untuk

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

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

Sumber:: Array.cs

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

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[]

Berbasis satu dimensi dan nol Array 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> yang digunakan saat membandingkan elemen.

-atau-

null untuk menggunakan IComparable<T> implementasi setiap elemen.

Mengembalikan

Int32

Pengecualian

ArgumentNullException

array adalah null.

ArgumentOutOfRangeException

index kurang dari batas arraybawah .

-atau-

length kurang dari nol.

ArgumentException

index dan length jangan tentukan rentang yang valid di array.

-atau-

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

InvalidOperationException

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

Keterangan

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

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

Elemen duplikat diizinkan. Array Jika 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 n adalah length.

Lihat juga

Berlaku untuk

Saran dan Komentar

Apakah halaman ini membantu?