Array.BinarySearch Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

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

Aşırı Yüklemeler

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

Kaynak:

Array.cs

Dizinin her öğesi ve belirtilen nesne tarafından uygulanan arabirimi 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);

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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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ğinde içindeki belirli bir nesneyi bulmak için nasıl kullanılacağı BinarySearch gösterilmektedir Array.

Not

Dizi, öğeleri artan sıralama düzeninde oluşturulur. yöntemi, BinarySearch dizinin artan düzende sıralanması gerekir.

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öntemi negatif bir tamsayı döndürür. Dizin oluşturmak için bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. 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, öğeleri array arama başlamadan önce için IComparable test edilmez. Arama uygulanmayan IComparablebir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnullvalue. 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 Lengtharray.

Ayrıca bkz.

• IComparable
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

BinarySearch(Array, Object, IComparer)

Kaynak:

Array.cs

Belirtilen IComparer arabirimi kullanarak tek boyutlu sıralanmış dizinin tamamında bir değer 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);

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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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öntemi negatif bir tamsayı döndürür. Dizin oluşturmak için bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. 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 karşılaştırma şeklini ö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.

nulldeğilsecomparer, öğeleri array belirtilen uygulama kullanılarak belirtilen IComparer değerle karşılaştırılır. öğelerinin array zaten değeri tarafından tanımlanan comparersıralama düzenine göre artan şekilde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

isecomparernull, 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.valuenull Arama uygulanmayan IComparablebir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnullvalue. 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 Lengtharray.

Ayrıca bkz.

• IComparer
• IComparable
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

BinarySearch(Array, Int32, Int32, Object)

Kaynak:

Array.cs

Dizinin her öğesi tarafından ve belirtilen değere göre uygulanan arabirimi kullanarak IComparable bir değer için tek boyutlu sıralanmış dizideki bir öğe aralığını 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);

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ığın uzunluğu.

value

Object

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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öntemi negatif bir tamsayı döndürür. Dizin oluşturmak için bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. 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 valueIComparable , öğeleri array arama başlamadan önce için IComparable test edilmez. Arama uygulanmayan IComparablebir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnullvalue. 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; burada n olur length.

Ayrıca bkz.

• IComparable
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

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

Kaynak:

Array.cs

Belirtilen IComparer arabirimi kullanarak bir değer için tek boyutlu sıralanmış dizideki bir öğ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);

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ığın 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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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öntemi negatif bir tamsayı döndürür. Dizin oluşturmak için bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. 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 karşılaştırma şeklini ö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.

nulldeğilsecomparer, öğeleri array belirtilen uygulama kullanılarak belirtilen IComparer değerle karşılaştırılır. öğelerinin array zaten değeri tarafından tanımlanan comparersıralama düzenine göre artan şekilde sıralanması gerekir; aksi takdirde sonuç yanlış olabilir.

ise comparernull, 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.valuenull Arama uygulanmayan IComparablebir öğeyle karşılaşırsa bir özel durum oluşturulur.

Yinelenen öğelere izin verilir. öğesine Array 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ılırken IComparablebir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable uygulamaya geçirilirnullvalue. 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; burada n olur length.

Ayrıca bkz.

• IComparer
• IComparable
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

BinarySearch<T>(T[], T)

Kaynak:

Array.cs

ve öğesinin her öğesi tarafından belirtilen nesneye göre 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 öğelerinin 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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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 yeniden görüntülenir. Yönteminin kullanılabilmesi BinarySearch için dizilerin sıralanması gerekir.

Not

Sort ve BinarySearch genel yöntemlerine 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, genel olmayan karşılıklarına yapılan çağrılardan farklı görünmemektedir. Microsoft ara dili (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 yer alırsa arasında düşeceği öğeler görüntülenir. Dize dizide değilse dizin negatiftir, bu nedenle ShowWhere yöntemi bit düzeyinde tamamlayıcıyı alır (C#'daki ~ işleci, F#'da ~~~ işleci, Visual Basic'de Xor-1) arama dizesinden daha büyük listedeki ilk öğenin dizinini elde etmek için.

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 dizilerde aramayı desteklemez. array bu yöntemi çağırmadan önce sıralanmalıdır.

Belirtilen değeri içermiyorsa array , yöntem negatif bir tamsayı döndürür. Dizin oluşturmak için bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, diziden daha value 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. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnullvalue. 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 öğesinin değeridir Lengtharray.

Ayrıca bkz.

• IComparable<T>
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

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

Kaynak:

Array.cs

Belirtilen IComparer<T> genel arabirimi kullanarak tek boyutlu 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);

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 öğelerinin 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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

ArgumentException

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

InvalidOperationException

comparer, 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<string> (Visual Basic'da IComparer(Of String)) genel arabirimini uygulayan ReverseCompare adlı dizeler için alternatif bir karşılaştırıcı tanımlar. Karşılaştırıcı yöntemini çağırır ve dizelerin düşük-yüksek yerine yüksek-düşük sıralanması için karşılaştırıcıların sırasını tersine çevirme CompareTo(String) .

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

Not

Sort<T>(T[], IComparer<T>) ve BinarySearch<T>(T[], T, IComparer<T>) genel yöntemlerine 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, genel olmayan karşılıklarına yapılan çağrılardan farklı görünmemektedir. Microsoft ara dili (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 yer alırsa arasında düşeceği öğeler görüntülenir. Dize dizide n değilse dizin negatif olur, bu nedenle ShowWhere yöntemi, listedeki arama dizesinden daha büyük olan listedeki ilk öğenin dizinini almak için bit düzeyinde tamamlayıcıyı (C#'daki ~ işleci, F#'daki ~~~ işleci, Visual Basic'de Xor -1) alır.

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 dizilerde 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 bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, 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 karşılaştırma şeklini ö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.

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

ise comparernull, 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, öğeleri array 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. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnullvalue. 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 öğesinin değeridir Lengtharray.

Ayrıca bkz.

• IComparer<T>
• IComparable<T>
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

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

Kaynak:

Array.cs

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

value

T

Aranacak nesne.

Döndürülenler

Int32

Belirtilen içinde belirtilen valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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

T genel arabirimi uygulamaz IComparable<T> .

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde 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 bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, diziden daha value 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. öğesine Array 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 karşılaştırmalar null özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnullvalue. 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; burada n olur length.

Ayrıca bkz.

• IComparable<T>
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme

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

Kaynak:

Array.cs

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

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 öğelerinin 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ığın 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 valuearrayöğesinin dizini 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 valuebüyük olan 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'e eşittir.

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 , nullve T genel arabirimini IComparable<T> uygulamaz.

Açıklamalar

Bu yöntem, negatif dizinler içeren dizilerde 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 bit düzeyinde tamamlayıcı işlecini (C#'ta~, Visual Basic Not) negatif sonuca uygulayabilirsiniz. Bu dizin dizinin boyutuna eşitse, 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 karşılaştırma şeklini ö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.

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

ise comparernull, 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. öğesine Array 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ılırken IComparable<T>bir özel durum oluşturmaz.

Not

Test edilen her öğe için, value olsa bile uygun IComparable<T> uygulamaya geçirilirnullvalue. 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; burada n olur length.

Ayrıca bkz.

• IComparer<T>
• IComparable<T>
• Sort
• Dizilerde Culture-Insensitive Dize İşlemleri Gerçekleştirme