List<T>.BinarySearch 메서드

정의

이진 검색 알고리즘을 사용하여 정렬된 List<T>나 그 일부에서 특정 요소를 찾습니다.Uses a binary search algorithm to locate a specific element in the sorted List<T> or a portion of it.

오버로드

BinarySearch(T)

기본 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches the entire sorted List<T> for an element using the default comparer and returns the zero-based index of the element.

BinarySearch(T, IComparer<T>)

지정된 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches the entire sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

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

지정된 비교자를 사용하여 정렬된 List<T>의 요소 범위에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches a range of elements in the sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

BinarySearch(T)

기본 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches the entire sorted List<T> for an element using the default comparer and returns the zero-based index of the element.

public:
 int BinarySearch(T item);
public int BinarySearch (T item);
member this.BinarySearch : 'T -> int
Public Function BinarySearch (item As T) As Integer

매개 변수

item
T

찾을 개체입니다.The object to locate. 참조 형식에 대해 값은 null이 될 수 있습니다.The value can be null for reference types.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.The zero-based index of item in the sorted List<T>, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of Count.

예외

기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 IComparable에 대한 T 인터페이스 구현을 찾을 수 없습니다.The default comparer Default cannot find an implementation of the IComparable<T> generic interface or the IComparable interface for type T.

예제

다음 예제에서는 Sort() 메서드 오버 로드와 BinarySearch(T) 메서드 오버 로드를 보여 줍니다.The following example demonstrates the Sort() method overload and the BinarySearch(T) method overload. 문자열의 List<T> 생성 되어 특정 순서로 4 개의 문자열로 채워집니다.A List<T> of strings is created and populated with four strings, in no particular order. 목록은 표시 하 고 정렬 하 고 다시 표시 됩니다.The list is displayed, sorted, and displayed again.

그런 다음 BinarySearch(T) 메서드 오버 로드를 사용 하 여 목록에 없는 두 문자열을 검색 하 고 Insert 메서드를 사용 하 여 해당 문자열을 삽입 합니다.The BinarySearch(T) method overload is then used to search for two strings that are not in the list, and the Insert method is used to insert them. 문자열이 목록에 없기 때문에 BinarySearch(T) 메서드의 반환 값은 각 경우에 음수입니다.The return value of the BinarySearch(T) method is negative in each case, because the strings are not in the list. 이 음수 값의 비트 보수 ( C# 및 시각적 개체 C++의 ~ 연산자, Visual Basic의 Xor-1)를 수행 하면 목록에서 검색 문자열 보다 큰 첫 번째 요소의 인덱스가 생성 되 고이 위치에 삽입 된 정렬 순서가 유지 됩니다.Taking the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) of this negative number produces the index of the first element in the list that is larger than the search string, and inserting at this location preserves the sort order. 두 번째 검색 문자열은 목록 끝에 삽입 위치 이므로 목록에 있는 모든 요소 보다 큰 합니다.The second search string is larger than any element in the list, so the insertion position is at the end of the list.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
    List<String^>^ dinosaurs = gcnew List<String^>();

    dinosaurs->Add("Pachycephalosaurus");
    dinosaurs->Add("Amargasaurus");
    dinosaurs->Add("Mamenchisaurus");
    dinosaurs->Add("Deinonychus");

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nSort");
    dinosaurs->Sort();

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch and Insert \"Coelophysis\":");
    int index = dinosaurs->BinarySearch("Coelophysis");
    if (index < 0)
    {
        dinosaurs->Insert(~index, "Coelophysis");
    }

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nBinarySearch and Insert \"Tyrannosaurus\":");
    index = dinosaurs->BinarySearch("Tyrannosaurus");
    if (index < 0)
    {
        dinosaurs->Insert(~index, "Tyrannosaurus");
    }

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs)
    {
        Console::WriteLine(dinosaur);
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus
 */
List<string> dinosaurs = new List<string>();

dinosaurs.Add("Pachycephalosaurus");
dinosaurs.Add("Amargasaurus");
dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus");

Console.WriteLine("Initial list:");
Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nSort:");
dinosaurs.Sort();

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Coelophysis\":");
int index = dinosaurs.BinarySearch("Coelophysis");
if (index < 0)
{
    dinosaurs.Insert(~index, "Coelophysis");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Tyrannosaurus\":");
index = dinosaurs.BinarySearch("Tyrannosaurus");
if (index < 0)
{
    dinosaurs.Insert(~index, "Tyrannosaurus");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}
/* This code example produces the following output:

Initial list:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort:

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus
*/
Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        dinosaurs.Sort

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Coelophysis"":")
        Dim index As Integer = dinosaurs.BinarySearch("Coelophysis")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Coelophysis")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Tyrannosaurus"":")
        index = dinosaurs.BinarySearch("Tyrannosaurus")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Tyrannosaurus")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Coelophysis":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Tyrannosaurus":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus

설명

이 메서드는 T 형식에 대 한 기본 비교자 Comparer<T>.Default를 사용 하 여 목록 요소의 순서를 결정 합니다.This method uses the default comparer Comparer<T>.Default for type T to determine the order of list elements. Comparer<T>.Default 속성은 형식 T IComparable<T> 제네릭 인터페이스를 구현 하는지 여부를 확인 하 고 사용 가능한 경우 해당 구현을 사용 합니다.The Comparer<T>.Default property checks whether type T implements the IComparable<T> generic interface and uses that implementation, if available. 그렇지 않은 경우 Comparer<T>.Default 형식 T에서 IComparable 인터페이스를 구현 하는지 여부를 확인 합니다.If not, Comparer<T>.Default checks whether type T implements the IComparable interface. 형식 T에서 두 인터페이스를 모두 구현 하지 않는 경우 Comparer<T>.Default InvalidOperationExceptionthrow 됩니다.If type T does not implement either interface, Comparer<T>.Default throws an InvalidOperationException.

List<T>은 이미 비교자 구현에 따라 정렬 되어야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.The List<T> must already be sorted according to the comparer implementation; otherwise, the result is incorrect.

null 참조 형식과 비교 하는 것은 허용 되며, IComparable<T> 제네릭 인터페이스를 사용 하는 경우 예외를 생성 하지 않습니다.Comparing null with any reference type is allowed and does not generate an exception when using the IComparable<T> generic interface. 정렬할 때 null은 다른 개체 보다 작은 것으로 간주 됩니다.When sorting, null is considered to be less than any other object.

List<T>에 동일한 값을 가진 둘 이상의 요소가 포함 된 경우 메서드는 발생 중 하나만 반환 하 고 첫 번째 값이 아닌 경우에는 발생 하는 항목 중 하나를 반환할 수 있습니다.If the List<T> contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.

List<T>에 지정 된 값이 포함 되어 있지 않으면이 메서드는 음의 정수를 반환 합니다.If the List<T> does not contain the specified value, the method returns a negative integer. 검색 값 보다 큰 첫 번째 요소의 인덱스를 가져올이 음의 정수 비트 보수 연산의 (~)를 적용할 수 있습니다.You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. List<T>에 값을 삽입할 때이 인덱스를 삽입 지점으로 사용 하 여 정렬 순서를 유지 해야 합니다.When inserting the value into the List<T>, this index should be used as the insertion point to maintain the sort order.

이 메서드는 O (log n) 연산입니다. 여기서 n 은 범위의 요소 수입니다.This method is an O(log n) operation, where n is the number of elements in the range.

추가 정보

BinarySearch(T, IComparer<T>)

지정된 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches the entire sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

public:
 int BinarySearch(T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch (T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (item As T, comparer As IComparer(Of T)) As Integer

매개 변수

item
T

찾을 개체입니다.The object to locate. 참조 형식에 대해 값은 null이 될 수 있습니다.The value can be null for reference types.

comparer
IComparer<T>

요소를 비교할 때 사용하는 IComparer<T> 구현입니다.The IComparer<T> implementation to use when comparing elements.

-또는--or- 기본 비교자 null를 사용하려면 Default입니다.null to use the default comparer Default.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.The zero-based index of item in the sorted List<T>, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of Count.

예외

comparernull이고 기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 IComparable에 대한 T 인터페이스 구현을 찾을 수 없습니다.comparer is null, and the default comparer Default cannot find an implementation of the IComparable<T> generic interface or the IComparable interface for type T.

예제

다음 예제에서는 Sort(IComparer<T>) 메서드 오버 로드와 BinarySearch(T, IComparer<T>) 메서드 오버 로드를 보여 줍니다.The following example demonstrates the Sort(IComparer<T>) method overload and the BinarySearch(T, IComparer<T>) method overload.

이 예제에서는 IComparer<string> (IComparer(Of String) Visual Basic, 시각적 개체 C++IComparer<String^>) 제네릭 인터페이스를 구현 하는 DinoCompare 라는 문자열에 대 한 대체 비교자를 정의 합니다.The example defines an alternative comparer for strings named DinoCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. 비교자는 다음과 같이 작동 합니다. 첫째, 비교는 null에 대해 테스트 되 고 null 참조는 null이 아닌 값으로 처리 됩니다.The comparer works as follows: First, the comparands are tested for null, and a null reference is treated as less than a non-null. 둘째, 문자열 길이 비교 하 고 더 긴 문자열인 큰 것으로 간주 됩니다.Second, the string lengths are compared, and the longer string is deemed to be greater. 셋째, 길이가 같으면 일반적인 문자열 비교가 됩니다.Third, if the lengths are equal, ordinary string comparison is used.

문자열의 List<T> 생성 되어 특정 순서로 4 개의 문자열로 채워집니다.A List<T> of strings is created and populated with four strings, in no particular order. 목록은 다시 표시 됩니다, 대체 비교자를 사용 하 여 정렬 및 표시.The list is displayed, sorted using the alternate comparer, and displayed again.

그런 다음 BinarySearch(T, IComparer<T>) 메서드 오버 로드를 사용 하 여 대체 비교자를 사용 하 여 목록에 없는 여러 문자열을 검색 합니다.The BinarySearch(T, IComparer<T>) method overload is then used to search for several strings that are not in the list, employing the alternate comparer. Insert 메서드는 문자열을 삽입 하는 데 사용 됩니다.The Insert method is used to insert the strings. 이러한 두 메서드는 SearchAndInsert라는 함수에 있으며 BinarySearch(T, IComparer<T>)에서 반환 되는 음수 값의 비트 보수 ( C# 및 시각적 개체 C++의 ~ 연산자, Visual Basic의 Xor-1)를 사용 하 여 새 문자열을 삽입 하기 위한 인덱스로 사용 합니다.These two methods are located in the function named SearchAndInsert, along with code to take the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) of the negative number returned by BinarySearch(T, IComparer<T>) and use it as an index for inserting the new string.

using namespace System;
using namespace System::Collections::Generic;

public ref class DinoComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        if (x == nullptr)
        {
            if (y == nullptr)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == nullptr)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x->Length.CompareTo(y->Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x->CompareTo(y);
                }
            }
        }
    }
};

void SearchAndInsert(List<String^>^ list, String^ insert, 
    DinoComparer^ dc)
{
    Console::WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

    int index = list->BinarySearch(insert, dc);

    if (index < 0)
    {
        list->Insert(~index, insert);
    }
};

void Display(List<String^>^ list)
{
    Console::WriteLine();
    for each(String^ s in list)
    {
        Console::WriteLine(s);
    }
};

void main()
{
    List<String^>^ dinosaurs = gcnew List<String^>();
    dinosaurs->Add("Pachycephalosaurus");
    dinosaurs->Add("Amargasaurus");
    dinosaurs->Add("Mamenchisaurus");
    dinosaurs->Add("Deinonychus");
    Display(dinosaurs);

    DinoComparer^ dc = gcnew DinoComparer();

    Console::WriteLine("\nSort with alternate comparer:");
    dinosaurs->Sort(dc);
    Display(dinosaurs);

    SearchAndInsert(dinosaurs, "Coelophysis", dc);
    Display(dinosaurs);

    SearchAndInsert(dinosaurs, "Oviraptor", dc);
    Display(dinosaurs);

    SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
    Display(dinosaurs);

    SearchAndInsert(dinosaurs, nullptr, dc);
    Display(dinosaurs);
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */
using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list, 
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

        int index = list.BinarySearch(insert, dc);

        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */
Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' If the strings are not of equal length,
                    ' the longer string is greater.
                    '
                    Return retval
                Else
                    ' If the strings are of equal length,
                    ' sort them with ordinary string comparison.
                    '
                    Return x.CompareTo(y)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)
        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & "Sort with alternate comparer:")
        dinosaurs.Sort(dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Coelophysis", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Oviraptor", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, Nothing, dc)
        Display(dinosaurs)
    End Sub

    Private Shared Sub SearchAndInsert( _
        ByVal lis As List(Of String), _
        ByVal insert As String, ByVal dc As DinoComparer)

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""{0}"":", insert)

        Dim index As Integer = lis.BinarySearch(insert, dc)

        If index < 0 Then
            index = index Xor -1
            lis.Insert(index, insert)
        End If
    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'
'Sort with alternate comparer:
'
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Coelophysis":
'
'Coelophysis
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Oviraptor":
'
'Oviraptor
'Coelophysis
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Tyrannosaur":
'
'Oviraptor
'Coelophysis
'Deinonychus
'Tyrannosaur
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "":
'
'
'Oviraptor
'Coelophysis
'Deinonychus
'Tyrannosaur
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus

설명

비교자는 요소를 비교 하는 방법을 사용자 지정 합니다.The comparer customizes how the elements are compared. 예를 들어 CaseInsensitiveComparer 인스턴스를 비교자로 사용 하 여 대/소문자를 구분 하지 않는 문자열 검색을 수행할 수 있습니다.For example, you can use a CaseInsensitiveComparer instance as the comparer to perform case-insensitive string searches.

comparer 제공 되는 경우 지정 된 IComparer<T> 구현을 사용 하 여 List<T>의 요소를 지정 된 값과 비교 합니다.If comparer is provided, the elements of the List<T> are compared to the specified value using the specified IComparer<T> implementation.

comparer null되는 경우 기본 비교자 Comparer<T>.Default 형식 T IComparable<T> 제네릭 인터페이스를 구현 하는지 여부를 확인 하 고 사용 가능한 경우 해당 구현을 사용 합니다.If comparer is null, the default comparer Comparer<T>.Default checks whether type T implements the IComparable<T> generic interface and uses that implementation, if available. 그렇지 않은 경우 Comparer<T>.Default 형식 T에서 IComparable 인터페이스를 구현 하는지 여부를 확인 합니다.If not, Comparer<T>.Default checks whether type T implements the IComparable interface. 형식 T에서 두 인터페이스를 모두 구현 하지 않는 경우 Comparer<T>.Default에서 InvalidOperationException을 throw 합니다.If type T does not implement either interface, Comparer<T>.Default throws InvalidOperationException.

List<T>은 이미 비교자 구현에 따라 정렬 되어야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.The List<T> must already be sorted according to the comparer implementation; otherwise, the result is incorrect.

null 참조 형식과 비교 하는 것은 허용 되며, IComparable<T> 제네릭 인터페이스를 사용 하는 경우 예외를 생성 하지 않습니다.Comparing null with any reference type is allowed and does not generate an exception when using the IComparable<T> generic interface. 정렬할 때 null은 다른 개체 보다 작은 것으로 간주 됩니다.When sorting, null is considered to be less than any other object.

List<T>에 동일한 값을 가진 둘 이상의 요소가 포함 된 경우 메서드는 발생 중 하나만 반환 하 고 첫 번째 값이 아닌 경우에는 발생 하는 항목 중 하나를 반환할 수 있습니다.If the List<T> contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.

List<T>에 지정 된 값이 포함 되어 있지 않으면이 메서드는 음의 정수를 반환 합니다.If the List<T> does not contain the specified value, the method returns a negative integer. 검색 값 보다 큰 첫 번째 요소의 인덱스를 가져올이 음의 정수 비트 보수 연산의 (~)를 적용할 수 있습니다.You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. List<T>에 값을 삽입할 때이 인덱스를 삽입 지점으로 사용 하 여 정렬 순서를 유지 해야 합니다.When inserting the value into the List<T>, this index should be used as the insertion point to maintain the sort order.

이 메서드는 O (log n) 연산입니다. 여기서 n 은 범위의 요소 수입니다.This method is an O(log n) operation, where n is the number of elements in the range.

추가 정보

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

지정된 비교자를 사용하여 정렬된 List<T>의 요소 범위에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.Searches a range of elements in the sorted List<T> for an element using the specified comparer and returns the zero-based index of the element.

public:
 int BinarySearch(int index, int count, T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch (int index, int count, T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : int * int * 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (index As Integer, count As Integer, item As T, comparer As IComparer(Of T)) As Integer

매개 변수

index
Int32

검색할 범위의 0부터 시작하는 인덱스입니다.The zero-based starting index of the range to search.

count
Int32

검색할 범위의 길이입니다.The length of the range to search.

item
T

찾을 개체입니다.The object to locate. 참조 형식에 대해 값은 null이 될 수 있습니다.The value can be null for reference types.

comparer
IComparer<T>

요소를 비교할 때 사용할 IComparer<T> 구현이거나, 기본 비교자 null를 사용하려면 Default입니다.The IComparer<T> implementation to use when comparing elements, or null to use the default comparer Default.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.The zero-based index of item in the sorted List<T>, if item is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than item or, if there is no larger element, the bitwise complement of Count.

예외

index가 0보다 작습니다.index is less than 0.

-또는--or- count가 0보다 작습니다.count is less than 0.

indexcountList<T>의 올바른 범위를 나타내지 않습니다.index and count do not denote a valid range in the List<T>.

comparernull이고 기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 IComparable에 대한 T 인터페이스 구현을 찾을 수 없습니다.comparer is null, and the default comparer Default cannot find an implementation of the IComparable<T> generic interface or the IComparable interface for type T.

예제

다음 예제에서는 Sort(Int32, Int32, IComparer<T>) 메서드 오버 로드와 BinarySearch(Int32, Int32, T, IComparer<T>) 메서드 오버 로드를 보여 줍니다.The following example demonstrates the Sort(Int32, Int32, IComparer<T>) method overload and the BinarySearch(Int32, Int32, T, IComparer<T>) method overload.

이 예제에서는 IComparer<string> (IComparer(Of String) Visual Basic, 시각적 개체 C++IComparer<String^>) 제네릭 인터페이스를 구현 하는 DinoCompare 라는 문자열에 대 한 대체 비교자를 정의 합니다.The example defines an alternative comparer for strings named DinoCompare, which implements the IComparer<string> (IComparer(Of String) in Visual Basic, IComparer<String^> in Visual C++) generic interface. 비교자는 다음과 같이 작동 합니다. 첫째, 비교는 null에 대해 테스트 되 고 null 참조는 null이 아닌 값으로 처리 됩니다.The comparer works as follows: First, the comparands are tested for null, and a null reference is treated as less than a non-null. 둘째, 문자열 길이 비교 하 고 더 긴 문자열인 큰 것으로 간주 됩니다.Second, the string lengths are compared, and the longer string is deemed to be greater. 셋째, 길이가 같으면 일반적인 문자열 비교가 됩니다.Third, if the lengths are equal, ordinary string comparison is used.

문자열의 List<T> 생성 되어 5 개의 herbivorous dinosaurs 및 carnivorous dinosaurs 라는 이름으로 채워집니다.A List<T> of strings is created and populated with the names of five herbivorous dinosaurs and three carnivorous dinosaurs. 각 두 그룹의 이름을 특정 정렬 순서에 있지 않습니다.Within each of the two groups, the names are not in any particular sort order. 목록이 표시 됩니다 하 고 초 식의 범위는 대체 비교자를 사용 하 여 정렬 된 목록이 다시 표시 됩니다.The list is displayed, the range of herbivores is sorted using the alternate comparer, and the list is displayed again.

그런 다음 BinarySearch(Int32, Int32, T, IComparer<T>) 메서드 오버 로드를 사용 하 여 "Brachiosaurus"에 대 한 herbivores 범위만 검색 합니다.The BinarySearch(Int32, Int32, T, IComparer<T>) method overload is then used to search only the range of herbivores for "Brachiosaurus". 문자열이 없고 BinarySearch(Int32, Int32, T, IComparer<T>) 메서드에서 반환 된 음수 값의 비트 보수 ( C# 및 시각적 개체 C++의 ~ 연산자, Visual Basic의 Xor-1)가 새 문자열을 삽입 하기 위한 인덱스로 사용 됩니다.The string is not found, and the bitwise complement (the ~ operator in C# and Visual C++, Xor -1 in Visual Basic) of the negative number returned by the BinarySearch(Int32, Int32, T, IComparer<T>) method is used as an index for inserting the new string.

using namespace System;
using namespace System::Collections::Generic;

public ref class DinoComparer: IComparer<String^>
{
public:
    virtual int Compare(String^ x, String^ y)
    {
        if (x == nullptr)
        {
            if (y == nullptr)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == nullptr)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x->Length.CompareTo(y->Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x->CompareTo(y);
                }
            }
        }
    }
};

void Display(List<String^>^ list)
{
    Console::WriteLine();
    for each(String^ s in list)
    {
        Console::WriteLine(s);
    }
};

void main()
{
    List<String^>^ dinosaurs = gcnew List<String^>();

    dinosaurs->Add("Pachycephalosaurus");
    dinosaurs->Add("Parasauralophus");
    dinosaurs->Add("Amargasaurus");
    dinosaurs->Add("Galimimus");
    dinosaurs->Add("Mamenchisaurus");
    dinosaurs->Add("Deinonychus");
    dinosaurs->Add("Oviraptor");
    dinosaurs->Add("Tyrannosaurus");

    int herbivores = 5;
    Display(dinosaurs);

    DinoComparer^ dc = gcnew DinoComparer();

    Console::WriteLine("\nSort a range with the alternate comparer:");
    dinosaurs->Sort(0, herbivores, dc);
    Display(dinosaurs);

    Console::WriteLine("\nBinarySearch a range and Insert \"{0}\":",
            "Brachiosaurus");

    int index = dinosaurs->BinarySearch(0, herbivores, "Brachiosaurus", dc);

    if (index < 0)
    {
        dinosaurs->Insert(~index, "Brachiosaurus");
        herbivores++;
    }

    Display(dinosaurs);
}

/* This code example produces the following output:

Pachycephalosaurus
Parasauralophus
Amargasaurus
Galimimus
Mamenchisaurus
Deinonychus
Oviraptor
Tyrannosaurus

Sort a range with the alternate comparer:

Galimimus
Amargasaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus

BinarySearch a range and Insert "Brachiosaurus":

Galimimus
Amargasaurus
Brachiosaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus
 */
using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal. 
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater. 
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the 
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Parasauralophus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Galimimus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Oviraptor");
        dinosaurs.Add("Tyrannosaurus");

        int herbivores = 5;
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort a range with the alternate comparer:");
        dinosaurs.Sort(0, herbivores, dc);
        Display(dinosaurs);

        Console.WriteLine("\nBinarySearch a range and Insert \"{0}\":",
            "Brachiosaurus");

        int index = dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc);

        if (index < 0)
        {
            dinosaurs.Insert(~index, "Brachiosaurus");
            herbivores++;
        }

        Display(dinosaurs);
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Parasauralophus
Amargasaurus
Galimimus
Mamenchisaurus
Deinonychus
Oviraptor
Tyrannosaurus

Sort a range with the alternate comparer:

Galimimus
Amargasaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus

BinarySearch a range and Insert "Brachiosaurus":

Galimimus
Amargasaurus
Brachiosaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus
 */
Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' If the strings are not of equal length,
                    ' the longer string is greater.
                    '
                    Return retval
                Else
                    ' If the strings are of equal length,
                    ' sort them with ordinary string comparison.
                    '
                    Return x.CompareTo(y)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Parasauralophus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Galimimus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        dinosaurs.Add("Oviraptor")
        dinosaurs.Add("Tyrannosaurus")

        Dim herbivores As Integer = 5
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & _
            "Sort a range with the alternate comparer:")
        dinosaurs.Sort(0, herbivores, dc)
        Display(dinosaurs)

        Console.WriteLine(vbLf & _
            "BinarySearch a range and Insert ""{0}"":", _
            "Brachiosaurus")

        Dim index As Integer = _
            dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc)

        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Brachiosaurus")
            herbivores += 1
        End If

        Display(dinosaurs)

    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Parasauralophus
'Amargasaurus
'Galimimus
'Mamenchisaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus
'
'Sort a range with the alternate comparer:
'
'Galimimus
'Amargasaurus
'Mamenchisaurus
'Parasauralophus
'Pachycephalosaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus
'
'BinarySearch a range and Insert "Brachiosaurus":
'
'Galimimus
'Amargasaurus
'Brachiosaurus
'Mamenchisaurus
'Parasauralophus
'Pachycephalosaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus

설명

비교자는 요소를 비교 하는 방법을 사용자 지정 합니다.The comparer customizes how the elements are compared. 예를 들어 CaseInsensitiveComparer 인스턴스를 비교자로 사용 하 여 대/소문자를 구분 하지 않는 문자열 검색을 수행할 수 있습니다.For example, you can use a CaseInsensitiveComparer instance as the comparer to perform case-insensitive string searches.

comparer 제공 되는 경우 지정 된 IComparer<T> 구현을 사용 하 여 List<T>의 요소를 지정 된 값과 비교 합니다.If comparer is provided, the elements of the List<T> are compared to the specified value using the specified IComparer<T> implementation.

comparer null되는 경우 기본 비교자 Comparer<T>.Default 형식 T IComparable<T> 제네릭 인터페이스를 구현 하는지 여부를 확인 하 고 사용 가능한 경우 해당 구현을 사용 합니다.If comparer is null, the default comparer Comparer<T>.Default checks whether type T implements the IComparable<T> generic interface and uses that implementation, if available. 그렇지 않은 경우 Comparer<T>.Default 형식 T에서 IComparable 인터페이스를 구현 하는지 여부를 확인 합니다.If not, Comparer<T>.Default checks whether type T implements the IComparable interface. 형식 T에서 두 인터페이스를 모두 구현 하지 않는 경우 Comparer<T>.Default에서 InvalidOperationException을 throw 합니다.If type T does not implement either interface, Comparer<T>.Default throws InvalidOperationException.

List<T>은 이미 비교자 구현에 따라 정렬 되어야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.The List<T> must already be sorted according to the comparer implementation; otherwise, the result is incorrect.

null 참조 형식과 비교 하는 것은 허용 되며, IComparable<T> 제네릭 인터페이스를 사용 하는 경우 예외를 생성 하지 않습니다.Comparing null with any reference type is allowed and does not generate an exception when using the IComparable<T> generic interface. 정렬할 때 null은 다른 개체 보다 작은 것으로 간주 됩니다.When sorting, null is considered to be less than any other object.

List<T>에 동일한 값을 가진 둘 이상의 요소가 포함 된 경우 메서드는 발생 중 하나만 반환 하 고 첫 번째 값이 아닌 경우에는 발생 하는 항목 중 하나를 반환할 수 있습니다.If the List<T> contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.

List<T>에 지정 된 값이 포함 되어 있지 않으면이 메서드는 음의 정수를 반환 합니다.If the List<T> does not contain the specified value, the method returns a negative integer. 검색 값 보다 큰 첫 번째 요소의 인덱스를 가져올이 음의 정수 비트 보수 연산의 (~)를 적용할 수 있습니다.You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. List<T>에 값을 삽입할 때이 인덱스를 삽입 지점으로 사용 하 여 정렬 순서를 유지 해야 합니다.When inserting the value into the List<T>, this index should be used as the insertion point to maintain the sort order.

이 메서드는 O (log n) 연산입니다. 여기서 n 은 범위의 요소 수입니다.This method is an O(log n) operation, where n is the number of elements in the range.

추가 정보

적용 대상