Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Array.BinarySearch<T> (Método) (T[], T, IComparer<T>)

 

Busca un valor por toda una matriz unidimensional y ordenada, utilizando la interfaz genérica IComparer<T> especificada.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

public static int BinarySearch<T>(
	T[] array,
	T value,
	IComparer<T> comparer
)

Parámetros

array

Matriz Array de base cero, unidimensional y ordenada en la que se va a buscar.

value

Objeto que se va a buscar.

comparer

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

o bien

null para utilizar la implementación de IComparable<T> de cada elemento.

Valor devuelto

Type: System.Int32

Índice del objeto value especificado en la matriz array especificada, si se encuentra el objeto value.Si no se encuentra value y value es menor que uno o varios elementos de array, un número negativo que es el complemento bit a bit del índice del primer elemento que sea mayor que value.Si no se encuentra value y value es mayor que cualquiera de los elementos de array, un número negativo que es el complemento bit a bit del índice del último elemento más uno.

Parámetros de tipo

T

Tipo de los elementos de la matriz.

Exception Condition
ArgumentNullException

El valor de array es null.

ArgumentException

comparer es null y value es de un tipo que no es compatible con los elementos de array.

InvalidOperationException

comparer es null, y T no implementa la interfaz genérica IComparable<T>

Este método no admite buscar en matrices con índices negativos. arrayse debe ordenar antes de llamar a este método.

Si la Array no contiene el valor especificado, el método devuelve un entero negativo.Puede aplicar el operador de complemento bit a bit (~ en C#, Not en Visual Basic) al resultado negativo para generar un índice.Si este índice es igual al tamaño de la matriz, no hay ningún elemento mayor que value en la matriz.De lo contrario, es el índice del primer elemento mayor que value.

El comparador personaliza cómo se comparan los elementos.Por ejemplo, puede utilizar un System.Collections.CaseInsensitiveComparer como comparador para realizar búsquedas de cadenas entre mayúsculas y minúsculas.

Si comparer no null, los elementos de array se comparan con el valor especificado mediante el objeto IComparer<T> implementación de interfaz genérica.Los elementos de array ya deben estar ordenados de forma ascendente según el criterio de ordenación definido por comparer; de lo contrario, es posible que el resultado sea incorrecto.

Si comparer es null, la comparación se realiza utilizando la IComparable<T> implementación de interfaz genérica proporcionada por T.Los elementos de array ya deben estar ordenados de forma ascendente según el criterio de ordenación definido por el IComparable<T> implementación; de lo contrario, es posible que el resultado sea incorrecto.

System_CAPS_noteNota

Si comparer es null y value no implementa la IComparable<T> interfaz genérica, los elementos de array no se han probado para IComparable<T> antes de que comience la búsqueda.Se produce una excepción si la búsqueda encuentra un elemento que no implementa IComparable<T>.

Se permiten elementos duplicados.Si el Array contiene más de un elemento igual a value, el método devuelve el índice de sólo una de las apariciones, no necesariamente la primera.

nullsiempre puede compararse con cualquier otro tipo de referencia; por lo tanto, las comparaciones con null no generan una excepción.

System_CAPS_noteNota

Para cada elemento probado, value se pasa a la correspondiente IComparable<T> implementación, incluso si value es null.Es decir, el IComparable<T> implementación determina cómo se compara un elemento especificado a null.

Este método es un O(log n) operación, donde n es el Length de array.

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

El ejemplo de código define un comparador alternativo para las cadenas, denominado ReverseCompare, que implementa el IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++) interfaz genérica.Las llamadas de comparador el CompareTo(String) método, invertir el orden de la comparación para que las cadenas ordenen alta o baja en lugar de bajo a alto.

La matriz se muestran, ordenada y volverá a aparecer.Puede ordenar las matrices para utilizar el BinarySearch<T> método.

System_CAPS_noteNota

Las llamadas a la Sort<T>(T[], IComparer<T>) y BinarySearch<T>(T[], T, IComparer<T>) métodos genéricos no presentan ninguna diferencia de las llamadas a sus homólogos no genéricos, puesto que Visual Basic, C# y C++ deducen el tipo del parámetro de tipo genérico del tipo del primer argumento.Si utiliza el Ildasm.exe (Desensamblador de IL) para examinar el lenguaje intermedio de Microsoft (MSIL), puede ver que se llama a los métodos genéricos.

El BinarySearch<T>(T[], T, IComparer<T>) , a continuación, se utiliza la sobrecarga del método genérico para buscar dos cadenas, una que no está en la matriz y uno que es.La matriz y el valor devuelto de la BinarySearch<T>(T[], T, IComparer<T>) método se pasan a la ShowWhere método genérico, que muestra el valor de índice si se encuentra la cadena; en caso contrario, los elementos de la cadena de búsqueda se encontrarían entre si estuviera en la matriz.El índice es negativo si la cadena no está en la matriz, por lo que la ShowWhere método toma el complemento bit a bit (el ~ operador en C# y Visual C++, Xor -1 en Visual Basic) para obtener el índice del primer elemento de la lista que es mayor que la cadena de búsqueda.

using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus", 
                              "Amargasaurus", 
                              "Tyrannosaurus", 
                              "Mamenchisaurus", 
                              "Deinonychus", 
                              "Edmontosaurus"};

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

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs, rc);

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */

Universal Windows Platform
Disponible desde 4.5
.NET Framework
Disponible desde 2.0
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: