Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

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 de tipo

T

Tipo de los elementos de la matriz.

Parámetros

array
Tipo: T[]
Matriz Array de base cero, unidimensional y ordenada en la que se va a buscar.
value
Tipo: T
Objeto que se va a buscar.
comparer
Tipo: System.Collections.Generic.IComparer<T>
Implementación de IComparer<T> que se va a utilizar al comparar elementos.
O bien
null para utilizar la implementación de IComparable<T> de cada elemento.

Valor devuelto

Tipo: 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.

ExcepciónCondición
ArgumentNullException

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 permite buscar en matrices con índices negativos. Antes de llamar a este método, se debe ordenar array.

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

El comparador personaliza la forma en que se comparan los elementos. Por ejemplo, se puede utilizar System.Collections.CaseInsensitiveComparer como comparador para realizar búsquedas de cadenas sin distinguir mayúsculas de minúsculas.

Si comparer no es null, los elementos de array se comparan con el valor especificado utilizando la implementación de la interfaz genérica IComparer<T> especificada. Los elementos de la matriz array ya deben estar ordenados de forma ascendente, siguiendo el criterio de ordenación definido por comparer; de lo contrario, el resultado podría ser incorrecto.

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

NotaNota

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

Se permiten elementos duplicados. Si Array contiene varios elementos iguales a value, el método solo devuelve el índice de una de las apariciones, no necesariamente la primera.

null se puede comparar siempre con cualquier otro tipo de referencia, por lo tanto, las comparaciones con null no generan excepciones.

NotaNota

   Para cada elemento probado, se pasa value a la implementación de IComparable<T> adecuada, aún cuando value sea null. Es decir, la implementación de IComparable<T> determina cómo se compara un elemento especificado con null.

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

El ejemplo siguiente se muestra la sobrecarga de método genérico de Sort<T>(T[], IComparer<T>) y la sobrecarga de método genérico de BinarySearch<T>(T[], T, IComparer<T>) .

En el ejemplo de código se define un comparador alternativo para las cadenas, denominado ReverseCompare, que implementa la interfaz genérica IComparer<string> (IComparer(Of String) en Visual Basic, IComparer<String^> en Visual C++). El comparador llama al método CompareTo(String), invirtiendo el orden de los términos de la comparación para que las cadenas se ordenen de mayor a menor, y no de menor a mayor.

Se muestra la matriz, se ordena y se vuelve a mostrar. Es necesario ordenar las matrices para utilizar el método BinarySearch.

NotaNota

Las llamadas a los métodos genéricos Sort<T>(T[], IComparer<T>) y BinarySearch<T>(T[], T, IComparer<T>) no presentan ninguna diferencia con respecto a 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 a partir del tipo del primer argumento. Si utiliza Ildasm.exe (Desensamblador de IL) para examinar el lenguaje intermedio de Microsoft (MSIL), puede ver que se llama a los métodos genéricos.

A continuación, se utiliza la sobrecarga del método genérico BinarySearch<T>(T[], T, IComparer<T>) para buscar dos cadenas, una que no está en la matriz y otra que sí está. La matriz y el valor devuelto del método BinarySearch<T>(T[], T, IComparer<T>) se pasan al método genérico ShowWhere, que muestra el valor del índice cuando se encuentra la cadena o, de lo contrario, los elementos entre los que se tendría que encontrar la cadena si estuviera en la matriz. El índice es negativo si la cadena no está en la matriz, de modo que el método ShowWhere toma un 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 buscada.


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


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft