다음을 통해 공유


List<T>.BinarySearch 메서드

정의

이진 검색 알고리즘을 사용하여 정렬된 List<T>나 그 일부에서 특정 요소를 찾습니다.

오버로드

BinarySearch(T)

기본 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

BinarySearch(T, IComparer<T>)

지정된 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

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

지정된 비교자를 사용하여 정렬된 List<T>의 요소 범위에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

BinarySearch(T)

Source:
List.cs
Source:
List.cs
Source:
List.cs

기본 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

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

찾을 개체입니다. 참조 형식에 대해 값은 null이 될 수 있습니다.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.

예외

기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 T에 대한 IComparable 인터페이스 구현을 찾을 수 없습니다.

예제

다음 예제에서는 메서드 오버로드 및 메서드 오버로드를 BinarySearch(T) 보여 Sort() 줍니다. List<T> 문자열의 은 특정 순서 없이 4개의 문자열로 만들어지고 채워집니다. 목록이 표시되고 정렬되고 다시 표시됩니다.

BinarySearch(T) 그런 다음 메서드 오버로드를 사용하여 목록에 없는 두 문자열을 검색하고 메서드를 Insert 사용하여 삽입합니다. 문자열이 BinarySearch(T) 목록에 없으므로 메서드의 반환 값은 각 경우에 음수입니다. 이 음수의 비트 보수(C# 및 Visual C++의 ~ 연산자, Xor Visual Basic의 경우 -1)를 사용하면 목록에서 검색 문자열보다 큰 첫 번째 요소의 인덱스가 생성되고 이 위치에 삽입하면 정렬 순서가 유지됩니다. 두 번째 검색 문자열은 목록의 요소보다 크므로 삽입 위치가 목록의 끝에 있습니다.

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 사용하여 목록 요소의 순서를 결정합니다. 속성은 Comparer<T>.Default 형식 T 이 제네릭 인터페이스를 IComparable<T> 구현하는지 여부를 확인하고 사용 가능한 경우 해당 구현을 사용합니다. 그렇지 않은 Comparer<T>.Default 경우 형식 T 이 인터페이스를 구현하는지 여부를 확인합니다 IComparable . 형식 T 이 두 인터페이스 Comparer<T>.Default 중 하나를 구현하지 않으면 을 InvalidOperationExceptionthrow합니다.

비교 List<T> 자 구현에 따라 를 이미 정렬해야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.

null 모든 참조 형식과 비교할 수 있으며 제네릭 인터페이스를 사용할 때 예외가 IComparable<T> 생성되지 않습니다. 정렬할 null 때 는 다른 개체보다 작은 것으로 간주됩니다.

List<T> 동일한 값을 가진 요소가 두 개 이상 포함된 경우 메서드는 발생 항목 중 하나만 반환하며 첫 번째 요소가 아닌 발생 중 하나를 반환할 수 있습니다.

List<T> 지정된 값을 포함하지 않으면 메서드는 음수 정수 를 반환합니다. 이 음수 정수에 비트 보수 연산(~)을 적용하여 검색 값보다 큰 첫 번째 요소의 인덱싱을 가져올 수 있습니다. 에 값을 List<T>삽입할 때 이 인덱스가 정렬 순서를 유지하려면 삽입 지점으로 사용해야 합니다.

이 메서드는 O(log n) 작업이며 여기서 n 은 범위의 요소 수입니다.

추가 정보

적용 대상

BinarySearch(T, IComparer<T>)

Source:
List.cs
Source:
List.cs
Source:
List.cs

지정된 비교자를 사용하여 정렬된 전체 List<T>에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

public:
 int BinarySearch(T item, System::Collections::Generic::IComparer<T> ^ comparer);
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

찾을 개체입니다. 참조 형식에 대해 값은 null이 될 수 있습니다.

comparer
IComparer<T>

요소를 비교할 때 사용하는 IComparer<T> 구현입니다.

또는

기본 비교자 Default를 사용하려면 null입니다.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.

예외

comparernull이고 기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 T에 대한 IComparable 인터페이스 구현을 찾을 수 없습니다.

예제

다음 예제에서는 메서드 오버로드 및 메서드 오버로드를 BinarySearch(T, IComparer<T>) 보여 Sort(IComparer<T>) 줍니다.

이 예제에서는 (Visual Basic IComparer<String^> 에서는 Visual C++에서)IComparer(Of String) 제네릭 인터페이스를 구현 IComparer<string> 하는 DinoCompare라는 문자열에 대한 대체 비교자를 정의합니다. 비교자는 다음과 같이 작동합니다. 첫째, 비교는 에 대해 null테스트되고 null 참조는 null이 아닌 참조보다 작게 처리됩니다. 둘째, 문자열 길이를 비교하고 긴 문자열은 더 큰 것으로 간주됩니다. 셋째, 길이가 같으면 일반 문자열 비교가 사용됩니다.

List<T> 문자열의 은 특정 순서 없이 4개의 문자열로 만들어지고 채워집니다. 목록이 표시되고, 대체 비교자를 사용하여 정렬되고, 다시 표시됩니다.

BinarySearch(T, IComparer<T>) 그런 다음 메서드 오버로드는 대체 비교자를 사용하여 목록에 없는 여러 문자열을 검색하는 데 사용됩니다. 메서드는 Insert 문자열을 삽입하는 데 사용됩니다. 이러한 두 메서드는 에서 반환 BinarySearch(T, IComparer<T>) 된 음수의 비트 보수(C#의 ~ 연산자 및 Visual C++의 Xor 경우 -1)를 가져와서 새 문자열을 삽입하기 위한 인덱스로 사용하는 코드와 함께 이라는 SearchAndInsert함수에 있습니다.

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

설명

비교자는 요소를 비교하는 방법을 사용자 지정합니다. 예를 들어 instance 비교자로 사용하여 CaseInsensitiveComparer 대/소문자를 구분하지 않는 문자열 검색을 수행할 수 있습니다.

가 제공된 경우 comparerList<T> 요소는 지정된 구현을 사용하여 지정된 값과 비교됩니다 IComparer<T> .

가 이nullcomparer 기본 비교자는 Comparer<T>.Default 형식 T 이 제네릭 인터페이스를 IComparable<T> 구현하고 사용 가능한 경우 해당 구현을 사용하는지 여부를 확인합니다. 그렇지 않은 Comparer<T>.Default 경우 형식 T 이 인터페이스를 구현하는지 여부를 확인합니다 IComparable . 형식 T 이 두 인터페이스 Comparer<T>.Default 중 하나를 구현하지 않으면 을 throw합니다 InvalidOperationException.

비교 List<T> 자 구현에 따라 를 이미 정렬해야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.

null 모든 참조 형식과 비교할 수 있으며 제네릭 인터페이스를 사용할 때 예외가 IComparable<T> 생성되지 않습니다. 정렬할 null 때 는 다른 개체보다 작은 것으로 간주됩니다.

List<T> 동일한 값을 가진 요소가 두 개 이상 포함된 경우 메서드는 발생 항목 중 하나만 반환하며 첫 번째 요소가 아닌 발생 중 하나를 반환할 수 있습니다.

List<T> 지정된 값을 포함하지 않으면 메서드는 음수 정수 를 반환합니다. 이 음수 정수에 비트 보수 연산(~)을 적용하여 검색 값보다 큰 첫 번째 요소의 인덱싱을 가져올 수 있습니다. 에 값을 List<T>삽입할 때 이 인덱스가 정렬 순서를 유지하려면 삽입 지점으로 사용해야 합니다.

이 메서드는 O(log n) 작업이며 여기서 n 은 범위의 요소 수입니다.

추가 정보

적용 대상

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

Source:
List.cs
Source:
List.cs
Source:
List.cs

지정된 비교자를 사용하여 정렬된 List<T>의 요소 범위에서 요소를 검색하고 요소의 인덱스(0부터 시작)를 반환합니다.

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);
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부터 시작하는 인덱스입니다.

count
Int32

검색할 범위의 길이입니다.

item
T

찾을 개체입니다. 참조 형식에 대해 값은 null이 될 수 있습니다.

comparer
IComparer<T>

요소를 비교할 때 사용할 IComparer<T> 구현이거나, 기본 비교자 Default를 사용하려면 null입니다.

반환

item이 있으면 정렬된 List<T>에 있는 item의 인덱스(0부터 시작)이고, 그렇지 않으면 item보다 큰 다음 요소의 인덱스에 대한 비트 보수인 음수이거나 더 큰 요소가 없는 경우 Count의 비트 보수입니다.

예외

index 가 0보다 작습니다.

또는

count 가 0보다 작습니다.

indexcountList<T>의 올바른 범위를 나타내지 않습니다.

comparernull이고 기본 비교자 DefaultIComparable<T> 제네릭 인터페이스 또는 형식 T에 대한 IComparable 인터페이스 구현을 찾을 수 없습니다.

예제

다음 예제에서는 메서드 오버로드 및 메서드 오버로드를 BinarySearch(Int32, Int32, T, IComparer<T>) 보여 Sort(Int32, Int32, IComparer<T>) 줍니다.

이 예제에서는 (Visual Basic IComparer<String^> 에서는 Visual C++에서)IComparer(Of String) 제네릭 인터페이스를 구현 IComparer<string> 하는 DinoCompare라는 문자열에 대한 대체 비교자를 정의합니다. 비교자는 다음과 같이 작동합니다. 첫째, 비교는 에 대해 null테스트되고 null 참조는 null이 아닌 참조보다 작게 처리됩니다. 둘째, 문자열 길이를 비교하고 긴 문자열은 더 큰 것으로 간주됩니다. 셋째, 길이가 같으면 일반 문자열 비교가 사용됩니다.

문자열의 List<T> 5 초식 공룡과 세 육식 공룡의 이름으로 생성되고 채워집니다. 두 그룹 각각 내에서 이름은 특정 정렬 순서가 아닙니다. 목록이 표시되고, 초식 동물 범위가 대체 비교자를 사용하여 정렬되고 목록이 다시 표시됩니다.

BinarySearch(Int32, Int32, T, IComparer<T>) 그런 다음 메서드 오버로드는 "Brachiosaurus"에 대한 초식 동물의 범위만 검색하는 데 사용됩니다. 문자열을 찾을 수 없으며 메서드에서 반환 BinarySearch(Int32, Int32, T, IComparer<T>) 된 음수의 비트 보수(C#의 ~ 연산자 및 Visual C++의 Xor 경우 -1)는 새 문자열을 삽입하기 위한 인덱스로 사용됩니다.

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

설명

비교자는 요소를 비교하는 방법을 사용자 지정합니다. 예를 들어 instance 비교자로 사용하여 CaseInsensitiveComparer 대/소문자를 구분하지 않는 문자열 검색을 수행할 수 있습니다.

가 제공된 경우 comparerList<T> 요소는 지정된 구현을 사용하여 지정된 값과 비교됩니다 IComparer<T> .

가 이nullcomparer 기본 비교자는 Comparer<T>.Default 형식 T 이 제네릭 인터페이스를 IComparable<T> 구현하고 사용 가능한 경우 해당 구현을 사용하는지 여부를 확인합니다. 그렇지 않은 Comparer<T>.Default 경우 형식 T 이 인터페이스를 구현하는지 여부를 확인합니다 IComparable . 형식 T 이 두 인터페이스 Comparer<T>.Default 중 하나를 구현하지 않으면 을 throw합니다 InvalidOperationException.

비교 List<T> 자 구현에 따라 를 이미 정렬해야 합니다. 그렇지 않으면 결과가 올바르지 않습니다.

null 모든 참조 형식과 비교할 수 있으며 제네릭 인터페이스를 사용할 때 예외가 IComparable<T> 생성되지 않습니다. 정렬할 null 때 는 다른 개체보다 작은 것으로 간주됩니다.

List<T> 동일한 값을 가진 요소가 두 개 이상 포함된 경우 메서드는 발생 항목 중 하나만 반환하며 첫 번째 요소가 아닌 발생 중 하나를 반환할 수 있습니다.

List<T> 지정된 값을 포함하지 않으면 메서드는 음수 정수 를 반환합니다. 이 음수 정수에 비트 보수 연산(~)을 적용하여 검색 값보다 큰 첫 번째 요소의 인덱싱을 가져올 수 있습니다. 에 값을 List<T>삽입할 때 이 인덱스가 정렬 순서를 유지하려면 삽입 지점으로 사용해야 합니다.

이 메서드는 O(log n) 작업이며 여기서 n 은 범위의 요소 수입니다.

추가 정보

적용 대상