Array.BinarySearch Yöntem
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
İ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
- value
- Object
Aranacak nesne.
Döndürülenler
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
bulunsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
array
çok boyutludur.
value
, öğeleriyle uyumlu olmayan bir türdedir array
.
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 value
bü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 uygulamazsavalue
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 value
olan 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
öğesinin değeridir Length array
.
Ayrıca bkz.
Şunlara uygulanır
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
- 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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
bulunsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
array
çok boyutludur.
comparer
, null
ve value
öğeleriyle uyumlu olmayan bir türdedir array
.
comparer
, null
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 value
bü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 comparer
sı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 value
olan 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
öğesinin değeridir Length array
.
Ayrıca bkz.
Şunlara uygulanır
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
- index
- Int32
Aranacak aralığın başlangıç dizini.
- length
- Int32
Aranacak aralık uzunluğu.
- value
- Object
Aranacak nesne.
Döndürülenler
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
bulunsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
array
çok boyutludur.
index
ve length
içinde array
geçerli bir aralık belirtmeyin.
-veya-
value
, öğeleriyle uyumlu olmayan bir türdedir array
.
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 value
bü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 value
olan 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
olur length
.
Ayrıca bkz.
Şunlara uygulanır
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
- 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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
bulunsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
array
çok boyutludur.
index
ve length
içinde array
geçerli bir aralık belirtmeyin.
-veya-
comparer
, null
ve value
öğeleriyle uyumlu olmayan bir türdedir array
.
comparer
, null
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 value
bü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 comparer
sı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 value
olan 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
olur length
.
Ayrıca bkz.
Şunlara uygulanır
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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
mevcut olsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
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, Xor
Visual 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 value
bü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 value
birden 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
değeridir Length array
.
Ayrıca bkz.
Şunlara uygulanır
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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
mevcut olsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
comparer
, null
ve value
öğeleriyle array
uyumlu olmayan bir türdedir.
comparer
olur null
ve 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ı ReverseCompare
dizeler 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 value
bü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 comparer
sı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 T
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.
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 value
birden 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
değeridir Length array
.
Ayrıca bkz.
Şunlara uygulanır
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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
mevcut olsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
index
ve length
içinde array
geçerli bir aralık belirtmeyin.
-veya-
value
, öğeleriyle array
uyumlu olmayan bir türdedir.
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 value
bü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 value
birden 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
olur length
.
Ayrıca bkz.
Şunlara uygulanır
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
Belirtilen içinde belirtilen value
array
dizini bulunursa value
, aksi takdirde negatif bir sayıdır. bulunamazsa ve value
içinde array
bir veya daha fazla öğeden küçüksevalue
, döndürülen negatif sayı, değerinden büyük value
olan ilk öğenin dizininin bit düzeyinde tamamlayıcısı olur. bulunamazsa ve value
içindeki array
tü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ış array
bir ile çağrılırsa, dönüş değeri yanlış olabilir ve içinde array
mevcut olsa value
bile negatif bir sayı döndürülebilir.
Özel durumlar
array
, null
değeridir.
index
ve length
içinde array
geçerli bir aralık belirtmeyin.
-veya-
comparer
, null
ve value
öğeleriyle array
uyumlu olmayan bir türdedir.
comparer
şeklindedir null
ve 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 value
bü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 comparer
sı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ü T
iç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 value
birden 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ı null
belirler.
Bu yöntem bir O(log n
) işlemidir ve burada n
olur length
.