List<T>.BinarySearch Método

  • Referencia

Definición

Espacio de nombres:
System.Collections.Generic
Ensamblado:
System.Collections.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Utiliza un algoritmo de búsqueda binaria para localizar un elemento concreto en la List<T> ordenada o en una parte de ella.

Sobrecargas

BinarySearch(T)

Busca la List<T> completa ordenada para un elemento usando el comparador predeterminado y devuelve el índice de base cero del elemento.
BinarySearch(T, IComparer<T>)

Busca la List<T> completa ordenada para un elemento usando el comparador especificado y devuelve el índice de base cero del elemento.
BinarySearch(Int32, Int32, T, IComparer<T>)

Busca un elemento en un intervalo de elementos del objeto List<T> ordenado usando el comparador especificado y devuelve el índice de base cero del elemento.

BinarySearch(T)

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

Busca la List<T> completa ordenada para un elemento usando el comparador predeterminado y devuelve el índice de base cero del elemento.

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

Parámetros

item
T

Objeto que se va a buscar. El valor puede ser null para los tipos de referencia.

Devoluciones

Int32

Índice de base cero de item en la List<T> ordenada, si es que se encuentra item; en caso contrario, número negativo que es el complemento bit a bit del índice del siguiente elemento mayor que item o, si no hay ningún elemento mayor, el complemento bit a bit de Count.

Excepciones

InvalidOperationException

El comparador predeterminado Default no puede encontrar una implementación de la interfaz genérica IComparable<T> o la interfaz IComparable del tipo T.

Ejemplos

En el ejemplo siguiente se muestra la sobrecarga del Sort() método y la sobrecarga del BinarySearch(T) método. Se List<T> crea una de cadenas y se rellena con cuatro cadenas, en ningún orden determinado. La lista se muestra, se ordena y se muestra de nuevo.

A BinarySearch(T) continuación, la sobrecarga del método se usa para buscar dos cadenas que no están en la lista y el Insert método se usa para insertarlas. El valor devuelto del BinarySearch(T) método es negativo en cada caso, porque las cadenas no están en la lista. Tomando el complemento bit a bit (el operador ~ en C# y Visual C++, Xor -1 en Visual Basic) de este número negativo genera el índice del primer elemento de la lista que es mayor que la cadena de búsqueda y la inserción en esta ubicación conserva el criterio de ordenación. La segunda cadena de búsqueda es mayor que cualquier elemento de la lista, por lo que la posición de inserción está al final de la lista.

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

Comentarios

Este método usa el comparador Comparer<T>.Default predeterminado para el tipo T para determinar el orden de los elementos de lista. La Comparer<T>.Default propiedad comprueba si el tipo T implementa la IComparable<T> interfaz genérica y usa esa implementación, si está disponible. Si no es así, Comparer<T>.Default comprueba si el tipo T implementa la IComparable interfaz. Si el tipo T no implementa ninguna interfaz, Comparer<T>.Default produce un InvalidOperationException.

Ya List<T> debe ordenarse según la implementación del comparador; de lo contrario, el resultado es incorrecto.

Se null permite comparar con cualquier tipo de referencia y no genera una excepción al usar la IComparable<T> interfaz genérica. Al ordenar, null se considera menor que cualquier otro objeto.

List<T> Si contiene más de un elemento con el mismo valor, el método devuelve solo una de las repeticiones y podría devolver cualquiera de las repeticiones, no necesariamente la primera.

List<T> Si no contiene el valor especificado, el método devuelve un entero negativo. Puede aplicar la operación de complemento bit a bit (~) a este entero negativo para obtener el índice del primer elemento que es mayor que el valor de búsqueda. Al insertar el valor en List<T>, este índice se debe usar como punto de inserción para mantener el criterio de ordenación.

Este método es una operación de O(log n), donde n es el número de elementos del intervalo.

Consulte también

Se aplica a

BinarySearch(T, IComparer<T>)

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

Busca la List<T> completa ordenada para un elemento usando el comparador especificado y devuelve el índice de base cero del elemento.

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

Parámetros

item
T

Objeto que se va a buscar. El valor puede ser null para los tipos de referencia.

comparer
IComparer<T>

Implementación de IComparer<T> que se va a usar al comparar elementos.

o bien

null para utilizar el comparador predeterminado Default.

Devoluciones

Int32

Índice de base cero de item en la List<T> ordenada, si es que se encuentra item; en caso contrario, número negativo que es el complemento bit a bit del índice del siguiente elemento mayor que item o, si no hay ningún elemento mayor, el complemento bit a bit de Count.

Excepciones

InvalidOperationException

comparer es null, y el comparador predeterminado Default no puede encontrar una implementación de la interfaz genérica IComparable<T> o la interfaz IComparable del tipo T.

Ejemplos

En el ejemplo siguiente se muestra la sobrecarga del Sort(IComparer<T>) método y la sobrecarga del BinarySearch(T, IComparer<T>) método.

En el ejemplo se define un comparador alternativo para las cadenas denominadas DinoCompare, que implementa la IComparer<string> interfaz genérica (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). El comparador funciona de la siguiente manera: En primer lugar, los comparands se prueban para nully una referencia nula se trata como menor que un valor distinto de NULL. En segundo lugar, se comparan las longitudes de cadena y se considera que la cadena más larga es mayor. En tercer lugar, si las longitudes son iguales, se usa la comparación de cadenas normales.

Se List<T> crea una de cadenas y se rellena con cuatro cadenas, en ningún orden determinado. La lista se muestra, se ordena mediante el comparador alternativo y se muestra de nuevo.

A BinarySearch(T, IComparer<T>) continuación, la sobrecarga del método se usa para buscar varias cadenas que no están en la lista, utilizando el comparador alternativo. El Insert método se usa para insertar las cadenas. Estos dos métodos se encuentran en la función denominada SearchAndInsert, junto con el código para tomar el complemento bit a bit (el operador ~ en C# y Visual C++, Xor -1 en Visual Basic) del número negativo devuelto por BinarySearch(T, IComparer<T>) y usarlo como índice para insertar la nueva cadena.

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

Comentarios

El comparador personaliza cómo se comparan los elementos. Por ejemplo, puede usar una CaseInsensitiveComparer instancia como comparador para realizar búsquedas de cadenas que no distinguen mayúsculas de minúsculas.

Si comparer se proporciona , los elementos de List<T> se comparan con el valor especificado mediante la implementación especificada IComparer<T> .

Si comparer es null, el comparador Comparer<T>.Default predeterminado comprueba si el tipo T implementa la IComparable<T> interfaz genérica y usa esa implementación, si está disponible. Si no es así, Comparer<T>.Default comprueba si el tipo T implementa la IComparable interfaz. Si type T no implementa ninguna interfaz, Comparer<T>.Default inicia InvalidOperationException.

Ya List<T> debe ordenarse según la implementación del comparador; de lo contrario, el resultado es incorrecto.

Se null permite comparar con cualquier tipo de referencia y no genera una excepción al usar la IComparable<T> interfaz genérica. Al ordenar, null se considera menor que cualquier otro objeto.

List<T> Si contiene más de un elemento con el mismo valor, el método devuelve solo una de las repeticiones y podría devolver cualquiera de las repeticiones, no necesariamente la primera.

List<T> Si no contiene el valor especificado, el método devuelve un entero negativo. Puede aplicar la operación de complemento bit a bit (~) a este entero negativo para obtener el índice del primer elemento que es mayor que el valor de búsqueda. Al insertar el valor en List<T>, este índice se debe usar como punto de inserción para mantener el criterio de ordenación.

Este método es una operación de O(log n), donde n es el número de elementos del intervalo.

Consulte también

Se aplica a

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

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

Busca un elemento en un intervalo de elementos del objeto List<T> ordenado usando el comparador especificado y devuelve el índice de base cero del elemento.

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

Parámetros

index
Int32

Índice inicial de base cero del intervalo que se va a buscar.

count
Int32

Longitud del intervalo en el que se va a buscar.

item
T

Objeto que se va a buscar. El valor puede ser null para los tipos de referencia.

comparer
IComparer<T>

Implementación de IComparer<T> que se va a utilizar al comparar elementos, o null para utilizar el comparador predeterminado Default.

Devoluciones

Int32

Índice de base cero de item en la List<T> ordenada, si es que se encuentra item; en caso contrario, número negativo que es el complemento bit a bit del índice del siguiente elemento mayor que item o, si no hay ningún elemento mayor, el complemento bit a bit de Count.

Excepciones

ArgumentOutOfRangeException

index es menor que 0.

O bien

count es menor que 0.

ArgumentException

index y count no denotan un intervalo válido en List<T>.

InvalidOperationException

comparer es null, y el comparador predeterminado Default no puede encontrar una implementación de la interfaz genérica IComparable<T> o la interfaz IComparable del tipo T.

Ejemplos

En el ejemplo siguiente se muestra la sobrecarga del Sort(Int32, Int32, IComparer<T>) método y la sobrecarga del BinarySearch(Int32, Int32, T, IComparer<T>) método.

En el ejemplo se define un comparador alternativo para las cadenas denominadas DinoCompare, que implementa la IComparer<string> interfaz genérica (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). El comparador funciona de la siguiente manera: En primer lugar, los comparands se prueban para nully una referencia nula se trata como menor que un valor distinto de NULL. En segundo lugar, se comparan las longitudes de cadena y se considera que la cadena más larga es mayor. En tercer lugar, si las longitudes son iguales, se usa la comparación de cadenas normales.

Se List<T> crea una de cadenas y se rellena con los nombres de cinco dinosaurios herbívoros y tres dinosaurios carnívoros. Dentro de cada uno de los dos grupos, los nombres no están en ningún criterio de ordenación determinado. Se muestra la lista, el intervalo de herbívoros se ordena mediante el comparador alternativo y la lista se muestra de nuevo.

A BinarySearch(Int32, Int32, T, IComparer<T>) continuación, la sobrecarga del método se usa para buscar solo el rango de herbívoros para "Brachiosaurus". No se encuentra la cadena y el complemento bit a bit (el operador ~ en C# y Visual C++, Xor -1 en Visual Basic) del número negativo devuelto por el BinarySearch(Int32, Int32, T, IComparer<T>) método se usa como índice para insertar la nueva cadena.

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

Comentarios

El comparador personaliza cómo se comparan los elementos. Por ejemplo, puede usar una CaseInsensitiveComparer instancia como comparador para realizar búsquedas de cadenas que no distinguen mayúsculas de minúsculas.

Si comparer se proporciona , los elementos de List<T> se comparan con el valor especificado mediante la implementación especificada IComparer<T> .

Si comparer es null, el comparador Comparer<T>.Default predeterminado comprueba si el tipo T implementa la IComparable<T> interfaz genérica y usa esa implementación, si está disponible. Si no es así, Comparer<T>.Default comprueba si el tipo T implementa la IComparable interfaz. Si type T no implementa ninguna interfaz, Comparer<T>.Default inicia InvalidOperationException.

Ya List<T> debe ordenarse según la implementación del comparador; de lo contrario, el resultado es incorrecto.

Se null permite comparar con cualquier tipo de referencia y no genera una excepción al usar la IComparable<T> interfaz genérica. Al ordenar, null se considera menor que cualquier otro objeto.

List<T> Si contiene más de un elemento con el mismo valor, el método devuelve solo una de las repeticiones y podría devolver cualquiera de las repeticiones, no necesariamente la primera.

List<T> Si no contiene el valor especificado, el método devuelve un entero negativo. Puede aplicar la operación de complemento bit a bit (~) a este entero negativo para obtener el índice del primer elemento que es mayor que el valor de búsqueda. Al insertar el valor en List<T>, este índice se debe usar como punto de inserción para mantener el criterio de ordenación.

Este método es una operación de O(log n), donde n es el número de elementos del intervalo.

Consulte también

Se aplica a