Arrays.binarySearch() en Java con ejemplos | Conjunto 2 (Buscar en subarreglo)

Arreglos.binarySearch()| Conjunto 1 Cubre cómo encontrar un elemento en una array ordenada en Java. Este conjunto cubrirá «Cómo buscar una clave en una array dentro de un rango dado, incluido solo el índice de inicio».

Sintaxis:  

public static int binarySearch(data_type[] arr, int fromIndex, int toIndex, data_type key)

Parámetros:

arr – la array a buscar

fromIndex : el índice del primer elemento (inclusive) que se buscará

toIndex : el índice del último elemento (exclusivo) que se buscará

 clave  : el valor a buscar 

• Es un método incorporado estático definido en la clase Arrays (java.util.Arrays) en Java y devuelve el índice de la clave especificada que se encuentra dentro del rango especificado.
• Aquí, data_type puede ser cualquiera de los primitivos data_type : byte, char, double, int, float, short, long y Object también.
• La función anterior busca en un rango de la array especificada del tipo de datos dado la clave especificada utilizando un algoritmo de búsqueda binaria.
• El rango dentro del cual debe ordenarse la clave especificada que se va a buscar (como en el método Arrays.sort() ) antes de realizar esta llamada. De lo contrario, el resultado sería indefinido. Si la array especificada contiene varios valores iguales a la clave especificada, no hay garantía de cuál se encontrará.

Devoluciones: 
el índice de la clave especificada se encuentra dentro del rango especificado en la array especificada, de lo contrario (-(punto de inserción) – 1). 

El punto de inserción se define como un punto en el que se insertaría la clave especificada: el índice del primer elemento en el rango mayor que la clave, o toIndex si todos los elementos en el rango son menores que la clave especificada. 
Nota: Esto garantiza que el valor de retorno será >= 0 si y solo si se encuentra la clave.

Ejemplos:  

   byteArr[] = {10,20,15,22,35}

   key = 22 para buscar entre el rango de 2 a 4 en la array especificada.

   Salida: 3

   charArr[] = {‘g’,’p’,’q’,’c’,’i’}

   key = p para buscar entre el rango de 1 a 4 en la array especificada.

   Salida: 3

   intArr[] = {1,2,3,4,5,6}

   key = 3 para buscar entre el rango de 1 a 4 en la array especificada.

   Salida: 2

   dobleArr[] = {10.2,1.51,2.2,3.5}

   key = 1.5 para buscar entre el rango de 1 a 4 en la array especificada.

   Salida: -2 ya que es el punto de inserción de 1.5

   floatArr[] = {10.2f, 15.1f, 2.2f, 3.5f}

   key = 35.0 para buscar entre el rango de 1 a 4 en la array especificada.

   Salida: -5

  shortArr[] = {10,20,15,22,35}

  key = 5 para buscar entre el rango de 0 a 4 en la array especificada.

  Salida: -1

Implementación:
 

// Java program to demonstrate working of  binarySearch()
// method for specified range in a sorted array.
import java.util.Arrays;
 
public class GFG {
    public static void main(String[] args)
    {
        byte byteArr[] = { 10, 20, 15, 22, 35 };
        char charArr[] = { 'g', 'p', 'q', 'c', 'i' };
        int intArr[] = { 1, 2, 3, 4, 5, 6 };
        double doubleArr[] = { 10.2, 15.1, 2.2, 3.5 };
        float floatArr[] = { 10.2f, 15.1f, 2.2f, 3.5f };
        short shortArr[] = { 10, 20, 15, 22, 35 };
 
        Arrays.sort(byteArr);
        Arrays.sort(charArr);
        Arrays.sort(intArr);
        Arrays.sort(doubleArr);
        Arrays.sort(floatArr);
        Arrays.sort(shortArr);
 
        byte byteKey = 22;
        char charKey = 'p';
        int intKey = 3;
        double doubleKey = 1.5;
        float floatKey = 35;
        short shortKey = 5;
 
        System.out.println(
            byteKey + " found at index = "
            + Arrays.binarySearch(byteArr, 2, 4, byteKey));
        System.out.println(
            charKey + " found at index = "
            + Arrays.binarySearch(charArr, 1, 4, charKey));
        System.out.println(
            intKey + " found at index = "
            + Arrays.binarySearch(intArr, 1, 4, intKey));
        System.out.println(doubleKey + " found at index = "
                           + Arrays.binarySearch(
                               doubleArr, 1, 4, doubleKey));
        System.out.println(floatKey + " found at index = "
                           + Arrays.binarySearch(
                               floatArr, 1, 4, floatKey));
        System.out.println(shortKey + " found at index = "
                           + Arrays.binarySearch(
                               shortArr, 0, 4, shortKey));
    }
}

22 found at index = 3
p found at index = 3
3 found at index = 2
1.5 found at index = -2
35.0 found at index = -5
5 found at index = -1

Excepciones:  

1. IllegalArgumentException : se lanza cuando el índice inicial (fromIndex) es mayor que el índice final (toIndex) del rango especificado. (Significa: fromIndex > toIndex)
2. ArrayIndexOutOfBoundsException : se lanza si uno o ambos índices no son medios válidos fromIndex<0 o toIndex > arr.length.

Puntos importantes:  

• Si la lista de entrada no está ordenada, los resultados no están definidos.
• Si hay duplicados, no hay garantía de cuál se encontrará.

Referencia : 

https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch(int[],%20int)

Este artículo es una contribución de Nitsdheerendra . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.