Array.BinarySearch Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Bütünleştirilmiş Kod:

mscorlib.dll

Bütünleştirilmiş Kod:

netstandard.dll

İkili arama algoritması kullanarak bir değer için sıralanmış Array tek boyutlu aramalar.

Aşırı Yüklemeler

BinarySearch(Array, Object)	Dizinin her öğesi ve belirtilen nesne tarafından uygulanan arabirimini kullanarak IComparable tek boyutlu sıralanmış dizinin tamamını belirli bir öğe için arar.
BinarySearch(Array, Object, IComparer)	Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizinin tamamını arar.
BinarySearch(Array, Int32, Int32, Object)	Dizinin her öğesi tarafından ve belirtilen değere göre uygulanan arabirimini kullanarak IComparable tek boyutlu bir sıralanmış dizideki öğe aralığını bir değer için arar.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu bir sıralanmış dizideki öğe aralığını arar.
BinarySearch<T>(T[], T)	ve öğesinin her öğesi tarafından belirtilen nesne tarafından uygulanan genel arabirimi kullanarak IComparable<T> tek boyutlu sıralanmış dizinin tamamını belirli bir öğe Array için arar.
BinarySearch<T>(T[], T, IComparer<T>)	Belirtilen IComparer<T> genel arabirimi kullanarak tek boyutlu bir sıralanmış dizinin tamamında bir değer arar.
BinarySearch<T>(T[], Int32, Int32, T)	ve öğelerinin her biri tarafından belirtilen değere göre uygulanan genel arabirimi kullanarak IComparable<T> bir değer için tek boyutlu sıralanmış dizideki Array bir öğe aralığını arar.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Belirtilen IComparer<T> genel arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.

BinarySearch(Array, Object)

Dizinin her öğesi ve belirtilen nesne tarafından uygulanan arabirimini kullanarak IComparable tek boyutlu sıralanmış dizinin tamamını belirli bir öğe için arar.

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

Parametreler

array

Array

Aranacak tek boyutlu Array sıralanmış.

value

Object

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraybulunsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

RankException

array çok boyutludur.

ArgumentException

value , öğeleriyle uyumlu olmayan bir türdedir array.

InvalidOperationException

value arabirimini IComparable uygulamaz ve arama arabirimini uygulamayan bir öğeyle IComparable karşılaşır.

Örnekler

Aşağıdaki kod örneği, içinde belirli bir nesneyi Arraybulmak için nasıl kullanılacağını BinarySearch gösterir.

Not

Dizi, öğeleri artan sıralama düzeninde oluşturulur. BinarySearch yöntemi, dizinin artan düzende sıralanmış olmasını gerektirir.

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.

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Array belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Bit tabanlı tamamlayıcı işlecini (C# dilinde~ Visual BasicNot) negatif sonuca uygulayarak dizin oluşturabilirsiniz. Bu dizin dizinin üst sınırından büyükse, diziden daha value büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

ya da value her öğesi array karşılaştırmalar için kullanılan arabirimini uygulamalıdır IComparable . öğelerinin array zaten uygulama tarafından IComparable tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Not

Arabirimi uygulamazsavalueIComparable, array öğeleri arama başlamadan önce için IComparable test edilmez. Arama uygulaması IComparableolmayan bir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array eşit valueolan birden fazla öğe içeriyorsa, yöntemi yalnızca oluşumlardan birinin dizinini döndürür ve ilkinin olması gerekmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n öğesinin değeridir Length array.

Ayrıca bkz.

• IComparable
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

BinarySearch(Array, Object, IComparer)

Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizinin tamamını arar.

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

Parametreler

array

Array

Aranacak tek boyutlu Array sıralanmış.

value

Object

Aranacak nesne.

comparer

IComparer

IComparer Öğeleri karşılaştırırken kullanılacak uygulama.

-veya-

null her öğenin uygulamasını kullanmak IComparable için.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraybulunsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

RankException

array çok boyutludur.

ArgumentException

comparer , nullve value öğeleriyle uyumlu olmayan bir türdedir array.

InvalidOperationException

comparer, nullvalue arabirimini IComparable uygulamaz ve arama arabirimini uygulamayan bir öğeyle IComparable karşılaşır.

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Array belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Bit tabanlı tamamlayıcı işlecini (C# dilinde~ Visual BasicNot) negatif sonuca uygulayarak dizin oluşturabilirsiniz. Bu dizin dizinin üst sınırından büyükse, diziden daha value büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

Karşılaştırıcı, öğelerin nasıl karşılaştırılacağını özelleştirir. Örneğin, büyük/küçük harfe duyarsız dize aramaları gerçekleştirmek için karşılaştırıcı olarak bir System.Collections.CaseInsensitiveComparer kullanabilirsiniz.

değilse comparer null, öğeleri array belirtilen uygulama kullanılarak belirtilen değerle IComparer karşılaştırılır. öğelerinin array değeri tarafından tanımlanan comparersıralama düzenine göre artan değerde sıralanmış olması gerekir; aksi takdirde sonuç yanlış olabilir.

isecomparer``null, karşılaştırma, öğenin kendisi veya belirtilen değer tarafından sağlanan uygulama kullanılarak IComparable yapılır. öğelerinin array zaten uygulama tarafından IComparable tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Not

ise ve arabirimini IComparable uygulamazsacomparer, öğeleri array arama başlamadan önce için IComparable test edilmez.value null Arama uygulaması IComparableolmayan bir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array eşit valueolan birden fazla öğe içeriyorsa, yöntemi yalnızca oluşumlardan birinin dizinini döndürür ve ilkinin olması gerekmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n öğesinin değeridir Length array.

Ayrıca bkz.

• IComparer
• IComparable
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

BinarySearch(Array, Int32, Int32, Object)

Dizinin her öğesi tarafından ve belirtilen değere göre uygulanan arabirimini kullanarak IComparable tek boyutlu bir sıralanmış dizideki öğe aralığını bir değer için arar.

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

Parametreler

array

Array

Aranacak tek boyutlu Array sıralanmış.

index

Int32

Aranacak aralığın başlangıç dizini.

length

Int32

Aranacak aralık uzunluğu.

value

Object

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraybulunsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

RankException

array çok boyutludur.

ArgumentOutOfRangeException

index alt sınırından küçüktür array.

-veya-

length, sıfırdan küçüktür.

ArgumentException

index ve length içinde arraygeçerli bir aralık belirtmeyin.

-veya-

value , öğeleriyle uyumlu olmayan bir türdedir array.

InvalidOperationException

value arabirimini IComparable uygulamaz ve arama arabirimini uygulamayan bir öğeyle IComparable karşılaşır.

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Array belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Bit tabanlı tamamlayıcı işlecini (C# dilinde~ Visual BasicNot) negatif sonuca uygulayarak dizin oluşturabilirsiniz. Bu dizin dizinin üst sınırından büyükse, diziden daha value büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

ya da value her öğesi array karşılaştırmalar için kullanılan arabirimini uygulamalıdır IComparable . öğelerinin array zaten uygulama tarafından IComparable tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Not

Arabirimi uygulamazsa value IComparable , array öğeleri arama başlamadan önce için IComparable test edilmez. Arama uygulaması IComparableolmayan bir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array eşit valueolan birden fazla öğe içeriyorsa, yöntemi yalnızca oluşumlardan birinin dizinini döndürür ve ilkinin olması gerekmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n olur length.

Ayrıca bkz.

• IComparable
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

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

Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu bir sıralanmış dizideki öğe aralığını arar.

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

Parametreler

array

Array

Aranacak tek boyutlu Array sıralanmış.

index

Int32

Aranacak aralığın başlangıç dizini.

length

Int32

Aranacak aralık uzunluğu.

value

Object

Aranacak nesne.

comparer

IComparer

IComparer Öğeleri karşılaştırırken kullanılacak uygulama.

-veya-

null her öğenin uygulamasını kullanmak IComparable için.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraybulunsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

RankException

array çok boyutludur.

ArgumentOutOfRangeException

index alt sınırından küçüktür array.

-veya-

length, sıfırdan küçüktür.

ArgumentException

index ve length içinde arraygeçerli bir aralık belirtmeyin.

-veya-

comparer , nullve value öğeleriyle uyumlu olmayan bir türdedir array.

InvalidOperationException

comparer, nullvalue arabirimini IComparable uygulamaz ve arama arabirimini uygulamayan bir öğeyle IComparable karşılaşır.

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Array belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Bit tabanlı tamamlayıcı işlecini (C# dilinde~ Visual BasicNot) negatif sonuca uygulayarak dizin oluşturabilirsiniz. Bu dizin dizinin üst sınırından büyükse, diziden daha value büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

Karşılaştırıcı, öğelerin nasıl karşılaştırılacağını özelleştirir. Örneğin, büyük/küçük harfe duyarsız dize aramaları gerçekleştirmek için karşılaştırıcı olarak bir System.Collections.CaseInsensitiveComparer kullanabilirsiniz.

değilse comparer null, öğeleri array belirtilen uygulama kullanılarak belirtilen değerle IComparer karşılaştırılır. öğelerinin array değeri tarafından tanımlanan comparersıralama düzenine göre artan değerde sıralanmış olması gerekir; aksi takdirde sonuç yanlış olabilir.

ise comparer null, karşılaştırma, öğenin kendisi veya belirtilen değer tarafından sağlanan uygulama kullanılarak IComparable yapılır. öğelerinin array zaten uygulama tarafından IComparable tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Not

ise ve arabirimini IComparable uygulamazsacomparer, öğeleri array arama başlamadan önce için IComparable test edilmez.value null Arama uygulaması IComparableolmayan bir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array eşit valueolan birden fazla öğe içeriyorsa, yöntemi yalnızca oluşumlardan birinin dizinini döndürür ve ilkinin olması gerekmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları kullanırken IComparableözel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n olur length.

Ayrıca bkz.

• IComparer
• IComparable
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

BinarySearch<T>(T[], T)

ve öğesinin her öğesi tarafından belirtilen nesne tarafından uygulanan genel arabirimi kullanarak IComparable<T> tek boyutlu sıralanmış dizinin tamamını belirli bir öğe Array için arar.

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

Tür Parametreleri

T

Dizinin öğelerini türü.

Parametreler

array

T[]

Aranacak tek boyutlu, sıfır tabanlı Array sıralanmış.

value

T

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraymevcut olsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

InvalidOperationException

T genel arabirimi uygulamaz IComparable<T> .

Örnekler

Aşağıdaki kod örneği, genel yöntem aşırı yüklemesini Sort<T>(T[]) ve genel yöntem aşırı yüklemesini BinarySearch<T>(T[], T) gösterir. Belirli bir sırada olmayan bir dize dizisi oluşturulur.

Dizi görüntülenir, sıralanır ve tekrar görüntülenir. Yönteminin kullanılabilmesi BinarySearch için dizilerin sıralanması gerekir.

Not

ve BinarySearch genel yöntemlerine Sort yapılan çağrılar, Visual Basic, F#, C# ve C++ genel tür parametresinin türünü ilk bağımsız değişkenin türünden çıkardığından, kendi genel olmayan karşılıklarına yapılan çağrılardan farklı değildir. Microsoft ara dilini (MSIL) incelemek için Ildasm.exe (IL Disassembler) kullanırsanız, genel yöntemlerin çağrıldığını görebilirsiniz.

Genel BinarySearch<T>(T[], T) yöntem aşırı yüklemesi daha sonra biri dizide olmayan, diğeri de dizide olmayan iki dizeyi aramak için kullanılır. Dizi ve yönteminin BinarySearch dönüş değeri, dize bulunursa dizin değerini görüntüleyen genel yönteme ShowWhere ( showWhere F# örneğindeki işlev) geçirilir ve aksi takdirde arama dizesinin dizide olması durumunda arayacağı öğeler görüntülenir. Dize dizide değilse dizin negatiftir, bu nedenle ShowWhere yöntem listedeki arama dizesinden daha büyük olan ilk öğenin dizinini almak için bit düzeyinde tamamlayıcıyı (C# içindeki ~ işleci ve Visual C++, F# dilinde ~~~ işleci, XorVisual Basic'de -1) alır.

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.

Açıklamalar

Bu yöntem negatif dizinler içeren dizileri aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Belirtilen değeri içermiyorsa array , yöntemi negatif bir tamsayı döndürür. Dizin oluşturmak için negatif sonuca bit düzeyinde tamamlayıcı işlecini (C# dilinde~, Not Visual Basic) uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, dizidekinden value daha büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

T karşılaştırmalar için kullanılan genel arabirimi uygulamalıdır IComparable<T> . öğelerinin array zaten uygulama tarafından IComparable<T> tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Yinelenen öğelere izin verilir. Array öğesine eşit valuebirden fazla öğe içeriyorsa, yöntemi yalnızca bir yinelemenin dizinini döndürür ve ilk öğeyi döndürmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable<T> , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n değeridir Length array.

Ayrıca bkz.

• IComparable<T>
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

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

Belirtilen IComparer<T> genel arabirimi kullanarak tek boyutlu bir sıralanmış dizinin tamamında bir değer arar.

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

Tür Parametreleri

T

Dizinin öğelerini türü.

Parametreler

array

T[]

Aranacak tek boyutlu, sıfır tabanlı Array sıralanmış.

value

T

Aranacak nesne.

comparer

IComparer<T>

IComparer<T> Öğeleri karşılaştırırken kullanılacak uygulama.

-veya-

null her öğenin uygulamasını kullanmak IComparable<T> için.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraymevcut olsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

ArgumentException

comparer , nullve value öğeleriyle arrayuyumlu olmayan bir türdedir.

InvalidOperationException

comparerolur nullve T genel arabirimi uygulamaz IComparable<T>

Örnekler

Aşağıdaki örnekte genel yöntem aşırı yüklemesi ve BinarySearch<T>(T[], T, IComparer<T>) genel yöntem aşırı yüklemesi gösterilmektedirSort<T>(T[], IComparer<T>).

Kod örneği, (IComparer(Of String) Visual Basic IComparer<String^> visual C++'da) genel arabirimini IComparer<string> uygulayan adlı ReverseComparedizeler için alternatif bir karşılaştırıcı tanımlar. Karşılaştırıcı yöntemini çağırarak CompareTo(String) karşılaştırıcıların sırasını tersine çevirme ve böylece dizeler düşük-yüksek yerine yüksek-düşük sıralar.

Dizi görüntülenir, sıralanır ve tekrar görüntülenir. Yönteminin kullanılabilmesi BinarySearch için dizilerin sıralanması gerekir.

Not

ve BinarySearch<T>(T[], T, IComparer<T>) genel yöntemlerine Sort<T>(T[], IComparer<T>) yapılan çağrılar, Visual Basic, C# ve C++ genel tür parametresinin türünü ilk bağımsız değişkenin türünden çıkardığından, kendi genel olmayan karşılıklarına yapılan çağrılardan farklı değildir. Microsoft ara dilini (MSIL) incelemek için Ildasm.exe (IL Disassembler) kullanırsanız, genel yöntemlerin çağrıldığını görebilirsiniz.

Genel BinarySearch<T>(T[], T, IComparer<T>) yöntem aşırı yüklemesi daha sonra biri dizide olmayan, diğeri de dizide olmayan iki dizeyi aramak için kullanılır. Dizi ve yönteminin BinarySearch<T>(T[], T, IComparer<T>) dönüş değeri, dize bulunursa dizin değerini görüntüleyen genel yönteme ShowWhere ( showWhere F# örneğindeki işlev) geçirilir ve aksi takdirde arama dizesinin dizide olması durumunda arayacağı öğeler görüntülenir. Dize dizide n değilse dizin negatiftir, bu nedenle ShowWhere yöntem listedeki arama dizesinden daha büyük olan ilk öğenin dizinini almak için bit düzeyinde tamamlayıcıyı (C# ve Visual C++'daki ~ işleci, F# dilinde ~~~ işleci, Xor Visual Basic'de -1) alır.

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.

Açıklamalar

Bu yöntem negatif dizinler içeren dizileri aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Array belirtilen değeri içermiyorsa, yöntemi negatif bir tamsayı döndürür. Dizin oluşturmak için negatif sonuca bit düzeyinde tamamlayıcı işlecini (C# dilinde~, Not Visual Basic) uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, dizidekinden value daha büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

Karşılaştırıcı, öğelerin nasıl karşılaştırılacağını özelleştirir. Örneğin, büyük/küçük harfe duyarsız dize aramaları gerçekleştirmek için karşılaştırıcı olarak bir System.Collections.CaseInsensitiveComparer kullanabilirsiniz.

değilse comparer null, öğeleri array belirtilen genel arabirim uygulaması kullanılarak belirtilen IComparer<T> değerle karşılaştırılır. öğelerinin array , tarafından tanımlanan comparersıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde, sonuç yanlış olabilir.

ise comparer null, karşılaştırma tarafından sağlanan Tgenel arabirim uygulaması kullanılarak IComparable<T> yapılır. öğelerinin array zaten uygulama tarafından IComparable<T> tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Not

ise null ve genel arabirimini uygulamazsa IComparable<T> comparer, array öğeleri arama başlamadan önce için IComparable<T> test edilmezvalue. Arama uygulanmayan IComparable<T>bir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. Array öğesine eşit valuebirden fazla öğe içeriyorsa, yöntemi yalnızca bir yinelemenin dizinini döndürür ve ilk öğeyi döndürmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable<T> , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n değeridir Length array.

Ayrıca bkz.

• IComparer<T>
• IComparable<T>
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

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

ve öğelerinin her biri tarafından belirtilen değere göre uygulanan genel arabirimi kullanarak IComparable<T> bir değer için tek boyutlu sıralanmış dizideki Array bir öğe aralığını arar.

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

Tür Parametreleri

T

Dizinin öğelerini türü.

Parametreler

array

T[]

Aranacak tek boyutlu, sıfır tabanlı Array sıralanmış.

index

Int32

Aranacak aralığın başlangıç dizini.

length

Int32

Aranacak aralık uzunluğu.

value

T

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraymevcut olsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

ArgumentOutOfRangeException

index alt sınırından küçüktür array.

-veya-

length, sıfırdan küçüktür.

ArgumentException

index ve length içinde arraygeçerli bir aralık belirtmeyin.

-veya-

value , öğeleriyle arrayuyumlu olmayan bir türdedir.

InvalidOperationException

T genel arabirimi uygulamaz IComparable<T> .

Açıklamalar

Bu yöntem negatif dizinler içeren dizileri aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Dizi belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Dizin oluşturmak için negatif sonuca bit düzeyinde tamamlayıcı işlecini (C# dilinde~, Not Visual Basic) uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, dizidekinden value daha büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

T karşılaştırmalar için kullanılan genel arabirimi uygulamalıdır IComparable<T> . öğelerinin array zaten uygulama tarafından IComparable<T> tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Yinelenen öğelere izin verilir. Array öğesine eşit valuebirden fazla öğe içeriyorsa, yöntemi yalnızca bir yinelemenin dizinini döndürür ve ilk öğeyi döndürmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable<T> , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n olur length.

Ayrıca bkz.

• IComparable<T>
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme

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

Belirtilen IComparer<T> genel arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını arar.

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

Tür Parametreleri

T

Dizinin öğelerini türü.

Parametreler

array

T[]

Aranacak tek boyutlu, sıfır tabanlı Array sıralanmış.

index

Int32

Aranacak aralığın başlangıç dizini.

length

Int32

Aranacak aralık uzunluğu.

value

T

Aranacak nesne.

comparer

IComparer<T>

IComparer<T> Öğeleri karşılaştırırken kullanılacak uygulama.

-veya-

null her öğenin uygulamasını kullanmak IComparable<T> için.

Döndürülenler

Int32

Belirtilen içinde belirtilen value arraydizini bulunursa value , aksi takdirde negatif bir sayıdır. bulunamazsa ve value içinde arraybir veya daha fazla öğeden küçüksevalue, döndürülen negatif sayı, değerinden büyük valueolan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value içindeki arraytüm öğelerden büyüksevalue, döndürülen negatif sayı bit düzeyinde tamamlayıcıdır (son öğenin dizini artı 1). Bu yöntem sıralanmamış arraybir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde arraymevcut olsa value bile negatif bir sayı döndürülebilir.

Özel durumlar

ArgumentNullException

array, null değeridir.

ArgumentOutOfRangeException

index alt sınırından küçüktür array.

-veya-

length, sıfırdan küçüktür.

ArgumentException

index ve length içinde arraygeçerli bir aralık belirtmeyin.

-veya-

comparer , nullve value öğeleriyle arrayuyumlu olmayan bir türdedir.

InvalidOperationException

comparer şeklindedir nullve T genel arabirimi uygulamaz IComparable<T> .

Açıklamalar

Bu yöntem negatif dizinler içeren dizileri aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Dizi belirtilen değeri içermiyorsa, yöntem negatif bir tamsayı döndürür. Dizin oluşturmak için negatif sonuca bit düzeyinde tamamlayıcı işlecini (C# dilinde~, Not Visual Basic) uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, dizidekinden value daha büyük öğe yoktur. Aksi takdirde, değerinden valuebüyük olan ilk öğenin dizinidir.

Karşılaştırıcı, öğelerin nasıl karşılaştırılacağını özelleştirir. Örneğin, büyük/küçük harfe duyarsız dize aramaları gerçekleştirmek için karşılaştırıcı olarak bir System.Collections.CaseInsensitiveComparer kullanabilirsiniz.

değilse comparer null, öğeleri array belirtilen genel arabirim uygulaması kullanılarak belirtilen IComparer<T> değerle karşılaştırılır. öğelerinin array , tarafından tanımlanan comparersıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde, sonuç yanlış olabilir.

ise comparer null, karşılaştırma türü Tiçin sağlanan genel arabirim uygulaması kullanılarak IComparable<T> yapılır. öğelerinin array zaten uygulama tarafından IComparable<T> tanımlanan sıralama düzenine göre artan değerde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

Yinelenen öğelere izin verilir. Array öğesine eşit valuebirden fazla öğe içeriyorsa, yöntemi yalnızca bir yinelemenin dizinini döndürür ve ilk öğeyi döndürmez.

null her zaman başka bir başvuru türüyle karşılaştırılabilir; bu nedenle, ile null karşılaştırmaları kullanırken IComparable<T>özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnull``value. Başka bir ifadeyle IComparable<T> , uygulama belirli bir öğenin ile karşılaştırmasını nullbelirler.

Bu yöntem bir O(log n) işlemidir ve burada n olur length.

Ayrıca bkz.

• IComparer<T>
• IComparable<T>
• Sort
• Dizilerde Kültüre Duyarsız Dize İşlemlerini Gerçekleştirme