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.
Puntos importantes:
- Antes de llamar a este método, se debe ordenar la array.
- Este método devolverá el entero negativo si la array no contiene el valor especificado.
- La array debe ser unidimensional; de lo contrario, no se puede usar este método.
- La interfaz Icomparable debe ser implementada por el valor o cada elemento de la array.
- El método devolverá el índice de solo una de las ocurrencias si se encuentran más de un elemento coincidente en la array y no es necesario que el índice sea de la primera ocurrencia.
Hay un total de 8 métodos en la lista de sobrecarga de este método de la siguiente manera:
- Búsqueda binaria (array, objeto)
- Búsqueda binaria (array, objeto, IComparer)
- Búsqueda binaria (array, Int32, Int32, objeto)
- Búsqueda binaria (array, Int32, Int32, objeto, IComparer)
- Búsqueda binaria<T>(T[], T)
- Búsqueda binaria<T>(T[], T, IComparer<T>)
- Búsqueda binaria<T>(T[], Int32, Int32, T)
- Búsqueda binaria<T>(T[], Int32, Int32, T, IComparer<T>)
Método de búsqueda binaria (array, objeto)
Este método se utiliza para buscar un elemento específico en toda la array ordenada 1-D . Usó la interfaz IComparable que implementa cada elemento de la array 1-D y el objeto especificado. Este método es una operación O(log n), donde n es la longitud de la array especificada.
Sintaxis: public static int BinarySearch (Array arr, object val);
Parámetros:
arr: Es el arreglo 1-D ordenado 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 .
- RankException: si el arreglo es multidimensional.
- ArgumentException: si el valor es de un tipo que no es compatible con los elementos de arr .
- InvalidOperationException: si val no implementa la interfaz IComparable y la búsqueda encuentra un elemento que no implementa la interfaz IComparable.
Los siguientes programas ilustran el método discutido anteriormente:
Ejemplo 1:
C#
// C# program to illustrate the
// Array.BinarySearch(Array, Object)
// Method
using System;
class GFG {
// Main Method
public static void Main(String[] args)
{
// taking an 1-D Array
int[] arr = new int[7] { 1, 5, 7, 4, 6, 2, 3 };
// for this method array
// must be sorted
Array.Sort(arr);
Console.Write("The elements of Sorted Array: ");
// calling the method to
// print the values
display(arr);
// taking the element which is
// to search for in a variable
// It is not present in the array
object s = 8;
// calling the method containing
// BinarySearch method
result(arr, s);
// taking the element which is
// to search for in a variable
// It is present in the array
object s1 = 4;
// calling the method containing
// BinarySearch method
result(arr, s1);
}
// containing BinarySearch Method
static void result(int[] arr2, object k)
{
// using the method
int res = Array.BinarySearch(arr2, k);
if (res < 0) {
Console.WriteLine("\nThe element to search for "
+ "({0}) is not found.",
k);
}
else {
Console.WriteLine("The element to search for "
+ "({0}) is at index {1}.",
k, res);
}
}
// display method
static void display(int[] arr1)
{
// Displaying Elements of array
foreach(int i in arr1)
Console.Write(i + " ");
}
}
The elements of Sorted Array: 1 2 3 4 5 6 7 The element to search for (8) is not found. The element to search for (4) is at index 3.
Ejemplo 2:
C#
// C# program to illustrate the
// Array.BinarySearch(Array, Object)
// Method
using System;
class GFG {
// Main Method
public static void Main(String[] args)
{
// taking an 1-D Array
int[] arr = new int[7] { 1, 5, 7, 4, 6, 2, 3 };
// for this method array
// must be sorted
Array.Sort(arr);
Console.Write("The elements of Sorted Array: ");
// calling the method to
// print the values
display(arr);
// it will return a negative value as
// 9 is not present in the array
Console.WriteLine("\nIndex of 9 is: " + Array.BinarySearch(arr, 8));
}
// display method
static void display(int[] arr1)
{
// Displaying Elements of array
foreach(int i in arr1)
Console.Write(i + " ");
}
}
The elements of Sorted Array: 1 2 3 4 5 6 7 Index of 9 is: -8
Método BinarySearch (array, objeto, IComparer)
Este método se utiliza para buscar un elemento específico en toda la array ordenada 1-D mediante la interfaz IComparer especificada.
Sintaxis: public static int BinarySearch(Array arr, Object val, IComparer comparer)
Parámetros:
arr : La array ordenada unidimensional en la que ocurrirá la búsqueda.
val : El valor del objeto que se va a buscar.
comparer : cuando se comparan elementos, se utiliza la implementación de IComparer .
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.
- RankException: si arr es multidimensional.
- ArgumentException: si el rango es menor que el límite inferior O la longitud es menor que 0.
- ArgumentException: si el comparador es nulo y el valor es de un tipo que no es compatible con los elementos de arr .
- InvalidOperationException: si el comparador es nulo, el valor no implementa la interfaz IComparable y la búsqueda encuentra un elemento que no implementa la interfaz IComparable.
Ejemplo:
C#
// C# program to demonstrate the
// Array.BinarySearch(Array,
// Object, IComparer) Method
using System;
class GFG {
// Main Method
public static void Main()
{
// initializes a new Array.
Array arr = Array.CreateInstance(typeof(Int32), 5);
// Array elements
arr.SetValue(20, 0);
arr.SetValue(10, 1);
arr.SetValue(30, 2);
arr.SetValue(40, 3);
arr.SetValue(50, 4);
Console.WriteLine("The original Array");
// calling "display" function
display(arr);
Console.WriteLine("\nsorted array");
// sorting the Array
Array.Sort(arr);
display(arr);
Console.WriteLine("\n1st call");
// search for object 10
object obj1 = 10;
// call the "FindObj" function
FindObj(arr, obj1);
Console.WriteLine("\n2nd call");
object obj2 = 60;
FindObj(arr, obj2);
}
// find object method
public static void FindObj(Array Arr,
object Obj)
{
int index = Array.BinarySearch(Arr, Obj,
StringComparer.CurrentCulture);
if (index < 0) {
Console.WriteLine("The object {0} is not found\nNext"
+ " larger object is at index {1}",
Obj, ~index);
}
else {
Console.WriteLine("The object {0} is at index {1}",
Obj, index);
}
}
// display method
public static void display(Array arr)
{
foreach(int g in arr)
{
Console.WriteLine(g);
}
}
}
The original Array 20 10 30 40 50 sorted array 10 20 30 40 50 1st call The object 10 is at index 0 2nd call The object 60 is not found Next larger object is at index 5
Método de búsqueda binaria (array, Int32, Int32, objeto)
Este método se utiliza para buscar un valor en el rango de elementos en una array ordenada 1-D. Utiliza la interfaz IComparable implementada por cada elemento de la array y el valor especificado. Busca solo en un límite específico definido por el usuario.
Sintaxis: public static int BinarySearch(Array arr, int i, int len, object val);
Parámetros:
arr: Es una array 1-D en la que el usuario tiene que buscar un elemento.
i: Es el índice de inicio del rango desde donde el usuario desea iniciar la búsqueda.
len: Es la longitud del rango en el que el usuario quiere buscar.
val: Es el valor que el usuario busca.
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.
- RankException: si arr es multidimensional.
- ArgumentOutOfRangeException: si el índice es menor que el límite inferior de la array O la longitud es menor que 0.
- ArgumentException: si el índice y la longitud no especifican el rango válido en la array O el valor es del tipo que no es compatible con los elementos de la array.
- InvalidOperationException: si el valor no implementa la interfaz IComparable y la búsqueda encuentra un elemento que no implementa la interfaz IComparable.
Ejemplo:
C#
// C# Program to illustrate the use of
// Array.BinarySearch(Array, Int32,
// Int32, Object) Method
using System;
using System.IO;
class GFG {
// Main Method
static void Main()
{
// initializing the integer array
int[] intArr = { 42, 5, 7, 12, 56, 1, 32 };
// sorts the intArray as it must be
// sorted before using method
Array.Sort(intArr);
// printing the sorted array
foreach(int i in intArr) Console.Write(i + " "
+ "\n");
// intArr is the array we want to find
// and 1 is the starting index
// of the range to search. 5 is the
// length of the range to search.
// 32 is the object to search
int index = Array.BinarySearch(intArr, 1, 5, 32);
if (index >= 0) {
// if the element is found it
// returns the index of the element
Console.WriteLine("Index of 32 is : " + index);
}
else {
// if the element is not
// present in the array or
// if it is not in the
// specified range it prints this
Console.Write("Element is not found");
}
// intArr is the array we want to
// find. and 1 is the starting
// index of the range to search. 5 is
// the length of the range to search
// 44 is the object to search
int index1 = Array.BinarySearch(intArr, 1, 5, 44);
// as the element is not present
// it prints a negative value.
Console.WriteLine("Index of 44 is :" + index1);
}
}
1 5 7 12 32 42 56 Index of 32 is : 4 Index of 44 is :-7
BinarySearch(Array, Int32, Int32, Object, IComparer) Método
Este método se usa para buscar un valor en el rango de elementos en una array ordenada 1-D usando una interfaz IComparer específica.
Sintaxis: public static int BinarySearch(Array arr, int index, int length, Object value, IComparer comparer)
Parámetros:
arr : La array unidimensional ordenada que se va a buscar.
index : El índice inicial del rango desde el cual comenzará la búsqueda.
length : La longitud del rango en el que ocurrirá la búsqueda.
valor : El objeto a buscar.
comparer : al comparar elementos, utilice la implementación de IComparer .
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 el valor y el valor es menor que uno o más elementos de la array , el número negativo devuelto es el complemento bit a bit del índice del primer elemento que es mayor que el valor .
- Si no se encuentra el valor y el valor es mayor que todos los elementos de la array, 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 devuelto puede ser incorrecto y se puede devolver un número negativo, incluso si el valor está presente en la array.
Ejemplo: En este ejemplo, aquí usamos el método “ CreateInstance() ” para crear una array con tipo y almacena algún valor entero y busca algunos valores después de ordenar la array.
C#
// C# program to demonstrate the
// Array.BinarySearch(Array,
// Int32, Int32, Object,
// IComparer) Method
using System;
class GFG {
// Main Method
public static void Main()
{
// initializes a new Array.
Array arr = Array.CreateInstance(typeof(Int32), 8);
// Array elements
arr.SetValue(20, 0);
arr.SetValue(10, 1);
arr.SetValue(30, 2);
arr.SetValue(40, 3);
arr.SetValue(50, 4);
arr.SetValue(80, 5);
arr.SetValue(70, 6);
arr.SetValue(60, 7);
Console.WriteLine("The original Array");
// calling "display" function
display(arr);
Console.WriteLine("\nsorted array");
// sorting the Array
Array.Sort(arr);
display(arr);
Console.WriteLine("\n1st call");
// search for object 10
object obj1 = 10;
// call the "FindObj" function
FindObj(arr, obj1);
Console.WriteLine("\n2nd call");
object obj2 = 60;
FindObj(arr, obj2);
}
// find object method
public static void FindObj(Array Arr,
object Obj)
{
int index = Array.BinarySearch(Arr, 1, 4,
Obj, StringComparer.CurrentCulture);
if (index < 0) {
Console.WriteLine("The object {0} is not found\n"
+ "Next larger object is at index {1}",
Obj, ~index);
}
else {
Console.WriteLine("The object {0} is at "
+ "index {1}",
Obj, index);
}
}
// display method
public static void display(Array arr)
{
foreach(int g in arr)
{
Console.WriteLine(g);
}
}
}
The original Array 20 10 30 40 50 80 70 60 sorted array 10 20 30 40 50 60 70 80 1st call The object 10 is not found Next larger object is at index 1 2nd call The object 60 is not found Next larger object is at index 5
Publicación traducida automáticamente
Artículo escrito por Anshul_Aggarwal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA