El método Array.BinarySearch() se usa para buscar un valor en una array unidimensional ordenada . Este método utiliza el algoritmo de búsqueda binaria . Este algoritmo busca en una array ordenada dividiendo repetidamente el intervalo de búsqueda por la mitad. Comience con un intervalo que cubra todo el arreglo. Si el valor de la clave de búsqueda es menor que el elemento en el medio del intervalo, reduzca el intervalo a la mitad inferior. De lo contrario, redúcelo a la mitad superior. Verifique repetidamente hasta que se encuentre el valor o el intervalo esté vacío.
Hay un total de 8 métodos en la lista de sobrecarga de este método de la siguiente manera:
- Método de búsqueda binaria (array, objeto)
- Método BinarySearch (array, objeto, IComparer)
- Método de búsqueda binaria (array, Int32, Int32, objeto)
- BinarySearch(Array, Int32, Int32, Object, IComparer) Método
- Método BinarySearch<T>(T[], T)
- Método BinarySearch<T>(T[], T, IComparer<T>)
- Búsqueda binaria<T>(T[], Int32, Int32, T) Método
- Búsqueda binaria<T>(T[], Int32, Int32, T, IComparer<T>) Método
Aquí, los primeros 4 métodos ya se discuten en el Set-1 . Los últimos 4 métodos se discutirán en este conjunto
Método BinarySearch<T>(T[], T)
Este método busca un elemento específico en una array unidimensional ordenada. Buscará en toda la array. La búsqueda utiliza una interfaz genérica IComparable<T> que se implementa por cada elemento de la array o por un objeto específico.
Sintaxis: public static int BinarySearch<T>(T[] arr, T val);
Aquí, «T» es el tipo de los elementos de la array.Parámetros:
arr: Es el array ordenado unidimensional a buscar.
val: Es el objeto a buscar.
Valor devuelto: Devuelve el índice del valor especificado en el arr especificado si se encuentra el valor ; de lo contrario, devuelve un número negativo. Hay diferentes casos de valores de retorno de la siguiente manera:
- Si no se encuentra val y val es menor que uno o más elementos en el arr , el número negativo devuelto es el complemento bit a bit del índice del primer elemento que es mayor que val .
- Si no se encuentra el val y val es mayor que todos los elementos en el arr , el número negativo devuelto es el complemento bit a bit de (el índice del último elemento más 1).
- Si se llama a este método con una array no ordenada, el valor de retorno puede ser incorrecto y se podría devolver un número negativo, incluso si el valor está presente en el arr .
Excepciones:
- ArgumentNullException: si el arr es nulo.
- InvalidOperationException: si T no implementa la interfaz genérica IComparable<T>.
Ejemplo 1:
// C# program to demonstrate the use of
// BinarySearch<T>(T[], T) method
using System;
using System.Collections.Generic;
class GFG {
// Main Method
public static void Main()
{
string[] arr = {"ABC", "XYZ",
"JKL", "DEF", "MNO"};
Console.WriteLine("Original array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
// sort the array
Array.Sort(arr);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
// call "BinarySearch<T>(T[], T)" method
int index = Array.BinarySearch(arr, "GHI");
sort(arr, index);
}
// BinarySearch<T> method
private static void sort<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("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);
}
}
}
Original array ABC XYZ JKL DEF MNO After Sort ABC DEF JKL MNO XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL.
Ejemplo 2:
// C# program to demonstrate the use
// of BinarySearch<T>(T[], T) method
using System;
using System.Collections.Generic;
class GFG {
// Main Method
public static void Main()
{
int[] arr = {5, 7, 1, 3, 4, 2};
Console.WriteLine("Original array");
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
// sort the array
Array.Sort(arr);
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for '6':");
// call "BinarySearch<T>(T[], T)" method
int index = Array.BinarySearch(arr, 6);
sort(arr, index);
}
// BinarySearch<T> method
private static void sort<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("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);
}
}
}
Original array 5 7 1 3 4 2 After Sort 1 2 3 4 5 7 BinarySearch for '6': Sorts between: 5 and 7.
Método BinarySearch<T>(T[], T, IComparer<T>)
Este método busca un valor específico en una array ordenada unidimensional especificada mediante la interfaz genérica IComparer<T>.
Sintaxis: public static int BinarySearch<T> (T[] arr, T val, IComparer comparer);
Aquí, «T» es el tipo de los elementos de la array.Parámetros:
arr: Es la array ordenada unidimensional a buscar.
val: Es el objeto a buscar.
comparer: es la implementación de IComparer<T> para usar al comparar elementos.
Valor devuelto: Devuelve el índice del valor especificado en el arr especificado si se encuentra el valor ; de lo contrario, devuelve un número negativo. Hay diferentes casos de valores de retorno de la siguiente manera:
- Si no se encuentra val y val es menor que uno o más elementos en el arr , el número negativo devuelto es el complemento bit a bit del índice del primer elemento que es mayor que val .
- Si no se encuentra el val y val es mayor que todos los elementos en el arr , el número negativo devuelto es el complemento bit a bit de (el índice del último elemento más 1).
- Si se llama a este método con una array no ordenada, el valor de retorno puede ser incorrecto y se podría devolver un número negativo, incluso si el valor está presente en el arr .
Excepciones:
- ArgumentNullException: si la array es nula.
- InvalidOperationException: si el comparador es nulo y T no implementa la interfaz genérica IComparable<T>.
- ArgumentException: si el comparador es nulo y el valor es de un tipo que no es compatible con los elementos de la array.
Ejemplo:
// C# program to demonstrate the use of
// BinarySearch<T>(T[], T, IComparer<T>)
// method
using System;
using System.Collections.Generic;
class comparer : IComparer<string> {
public int Compare(string x, string y)
{
return x.CompareTo(y);
}
}
// Driver Class
class GFG {
// Main Method
public static void Main()
{
string[] arr = {"ABC", "XYZ",
"JKL", "DEF", "MNO"};
Console.WriteLine("Original Array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
// IComparer<T> object
comparer gg = new comparer();
Console.WriteLine("\nAfter Sort");
// sort the array
Array.Sort(arr, gg);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
// search for "GHI"
int index = Array.BinarySearch(arr, "GHI", gg);
sort(arr, index);
}
// BinarySearch<T> method
private static void sort<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("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);
}
}
}
Original Array ABC XYZ JKL DEF MNO After Sort ABC DEF JKL MNO XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL
Búsqueda binaria<T>(T[], Int32, Int32, T)
Este método busca un valor en un rango de elementos en una array ordenada unidimensional, mediante la interfaz genérica IComparable<T> implementada por cada elemento de la array o un valor especificado.
Sintaxis: public static int BinarySearch<T> (T[] arr, int start, int len, T val);
Aquí, «T» es el tipo de los elementos de la array.Parámetros:
arr: Es el array ordenado unidimensional a buscar.
inicio: Es el índice de inicio del rango a buscar.
len: Es la longitud del rango a buscar.
val: Es el objeto a buscar.
Valor devuelto: Devuelve el índice del valor especificado en el arr especificado si se encuentra el valor ; de lo contrario, devuelve un número negativo. Hay diferentes casos de valores de retorno de la siguiente manera:
- Si no se encuentra val y val es menor que uno o más elementos en el arr , el número negativo devuelto es el complemento bit a bit del índice del primer elemento que es mayor que val .
- Si no se encuentra el val y val es mayor que todos los elementos en el arr , el número negativo devuelto es el complemento bit a bit de (el índice del último elemento más 1).
- Si se llama a este método con una array no ordenada, el valor de retorno puede ser incorrecto y se podría devolver un número negativo, incluso si el valor está presente en el arr .
Excepciones:
- ArgumentNullException: si la array es nula.
- InvalidOperationException: si T no implementa la interfaz genérica IComparable<T>.
- ArgumentException: si start y len no especifican un rango válido en la array o el valor es de un tipo que no es compatible con los elementos de la array.
- ArgumentOutOfRangeException: si el inicio es menor que el límite inferior de la array.
Ejemplo:
// C# program to demonstrate the use of
// BinarySearch<T>(T[], Int32, Int32,
// T) method
using System;
using System.Collections.Generic;
class GFG {
public static void Main()
{
int[] arr = { 1, 5, 3, 4, 2, 7 };
Console.WriteLine("Original Array");
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
// sort the array
Array.Sort(arr);
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for '6':");
// search for "6" in a
// range of index 0 to 4
int index = Array.BinarySearch(arr, 0, 4, 6);
sort(arr, index);
}
// BinarySearch<T> method
private static void sort<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("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);
}
}
}
Original Array 1 5 3 4 2 7 After Sort 1 2 3 4 5 7 BinarySearch for '6': Sorts between: 4 and 5
Búsqueda binaria<T>(T[], Int32, Int32, T, IComparer<T>) Método
Este método busca un valor en un rango de elementos en una array ordenada unidimensional, mediante la interfaz genérica IComparer<T> especificada.
Sintaxis: public static int BinarySearch<T> (T[] array, int start, int len, T val, IComparer<T> comparer);
Aquí, «T» es el tipo de los elementos de la array.Parámetros:
arr: Es la array ordenada unidimensional a buscar.
inicio: Es el índice de inicio del rango a buscar.
len: Es la longitud del rango a buscar.
valor: Es el objeto a buscar.
comparer: es la implementación de IComparer<T> para usar al comparar elementos.
Valor devuelto: Devuelve el índice del valor especificado en el arr especificado si se encuentra el valor ; de lo contrario, devuelve un número negativo. Hay diferentes casos de valores de retorno de la siguiente manera:
- Si no se encuentra val y val es menor que uno o más elementos en el arr , el número negativo devuelto es el complemento bit a bit del índice del primer elemento que es mayor que val .
- Si no se encuentra el val y val es mayor que todos los elementos en el arr , el número negativo devuelto es el complemento bit a bit de (el índice del último elemento más 1).
- Si se llama a este método con una array no ordenada, el valor de retorno puede ser incorrecto y se podría devolver un número negativo, incluso si el valor está presente en el arr .
Excepciones:
- ArgumentNullException: si la array es nula.
- InvalidOperationException: si T no implementa la interfaz genérica IComparable<T>.
- ArgumentException: si start y len no especifican un rango válido en array o el comparador es nulo y val es de un tipo que no es compatible con los elementos de array.
- ArgumentOutOfRangeException: si start es menor que el límite inferior de array o len es menor que cero.
Ejemplo:
// C# program to demonstrate the use of
// BinarySearch<T>(T[], Int32, Int32,
// T, IComparer<T>) method
using System;
using System.Collections.Generic;
class comparer : IComparer<string> {
public int Compare(string x, string y)
{
return x.CompareTo(y);
}
}
class GFG {
// Main Method
public static void Main()
{
string[] arr = {"ABC", "UVW", "JKL",
"DEF", "MNO", "XYZ"};
Console.WriteLine("Original Array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
// IComparer<T> object
comparer gg = new comparer();
Console.WriteLine("\nAfter Sort");
// sort the array
Array.Sort(arr, gg);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
// search for "GHI"
// search happens in the
// range of index 1 to 4
int index = Array.BinarySearch(arr, 1, 4, "GHI", gg);
sort(arr, index);
}
// BinarySearch<T> method
private static void sort<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("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);
}
}
}
Original Array ABC UVW JKL DEF MNO XYZ After Sort ABC DEF JKL MNO UVW XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL
Referencia:
Publicación traducida automáticamente
Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA