List<T>.BinarySearch Método

Definición

Espacio de nombres:

System.Collections.Generic

Ensamblado:

System.Collections.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

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

C#

public int BinarySearch (T item);

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.

C#

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
*/

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

• Realizar operaciones de cadenas que no tienen en cuenta las referencias culturales en colecciones

BinarySearch(T, IComparer<T>)

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.

C#

public int BinarySearch (T item, System.Collections.Generic.IComparer<T>? comparer);

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.

C#

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
 */

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

• Realizar operaciones de cadenas que no tienen en cuenta las referencias culturales en colecciones

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

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.

C#

public int BinarySearch (int index, int count, T item, System.Collections.Generic.IComparer<T>? comparer);

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.

C#

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
 */

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

• IComparer<T>
• IComparable<T>
• Realizar operaciones de cadenas que no tienen en cuenta las referencias culturales en colecciones