Home >> Programación >> Java
Buscar un dato en un array es una de las operaciones más comunes que puedes realizar con arrays en Java. Es posible que tengas un dato y que necesites comprobar si está en alguna de las posiciones de un array.
Indistintamente de dónde provenga el dato (resultado de una operación previa, parámetro recibido en un método, valor devuelto por un método, etc.), lo que te voy a contar en este artículo te será de mucha utilidad para buscarlo en un array.
Como siempre, te planteo diferentes escenarios para que elijas el que mejor se adapte a tus necesidades:
Cómo buscar en un array desordenado
Vamos a empezar por el primer caso. Es el más sencillo, pero el menos eficiente: Buscar en un array desordenado.
Desde el punto de vista de la programación es el caso más sencillo porque el código es muy simple y la lógica también, pero desde el punto de vista de la eficiencia es el peor escenario, puesto que el número de iteraciones puede ser mayor en función de la posición que ocupe el dato a buscar (o si no existe).
Vamos al grano para que lo entiendas bien. El siguiente es el código que necesitas para hacer una búsqueda en un array desordenado:
/* Declaraciones necesarias: */
int n = 9;
int [] nums = {4,7,2,9,4,2};
int pos = -1;
/* Búsqueda: */
for (int i = 0; i < nums.length; i++) {
if(nums[i] == n){
pos = i;
break;
}
}
/* Comprobación del resultado: */
if(pos >= 0){
System.out.println("Número encontrado en la posición "+pos);
}else{
System.out.println("No se ha encontrado el número");
}
Declaraciones necesarias
El dato a buscar es la variable n (cuyo origen puede ser cualquiera) y el array en el que se realizará la búsqueda es nums.
Habrás notado que he declarado otra variable a parte de n y nums. La variable pos, es un entero, y me va a servir para almacenar la posición dentro del array que ocupa el dato que quiero buscar.
Si el dato estuviese más de una vez en el array guardaré en la variable pos la primera posición en la que lo encuentre. Si no estuviese el dato en el array el valor de pos permanecerá con su valor inicial: -1.
¿Por qué -1? Fácil, en un array no existen posiciones negativas, por lo que un valor positivo en esta variable significará que el dato está en el array, sin embargo, si el dato no está en el array su valor permanecerá sin cambios, es decir, será -1. Esta variable será útil para hacer la comprobación al final.
Búsqueda
Vamos a centrarnos ahora en el bucle for (línea 7), que es dónde realmente harás la búsqueda.
El for no tiene mucho misterio. Inicializo i a 0 (int i=0) y utilizo nums.length en la condición para recorrer el array entero, desde la posición 0 (primera) hasta la última. Esto ya lo hemos visto anteriormente en otros artículos (Si no sabes cómo recorrer un array en Java mira aquí).
¿Qué ocurre ahora dentro del for? Lo interesante realmente es la condición de la instrucción if: if(nums[i] == n). Lo que hago es comprobar si el dato que ocupa la posición i del array es igual al dato que busco y que se encuentra almacenado en la variable n. Si es cierto, la condición se cumple, por lo que el cuerpo del if se ejecuta:
if(nums[i] == n){
pos = i;
break;
}
La primera instrucción dentro del if almacena el valor de i en la variable pos, es decir, almacena la posición que ocupa el dato en el array en la variable pos. He encontrado el dato, por tanto, quiero saber dónde está.
La segunda instrucción dentro del if es un break. ¿Para qué sirve esto? Pues para que se detenga el bucle. No tiene sentido seguir recorriendo el array si ya encontraste el dato ¿No?
Imagina que quitas el break. Si el dato estuviese repetido a lo largo del array, en cada iteración en la que se cumpla la condición del if se sustituirá el valor de pos por la nueva posición en la que lo encuentres, por lo que el valor final de pos será la última posición en la que esté el dato y no la primera.
Si es eso lo que intentas, buscar la última ocurrencia del dato, entonces mejor recorre el array al revés y usa el break igualmente, es más eficiente.
Hay otro motivo más por el que debes utilizar el break. Imagina que el array no tiene datos repetidos, pero tiene 1000 elementos y el dato que buscas está en la primera posición. El if encontrará el dato en la primera iteración del for. Al ejecutar el break el for se detiene y ya no hace más repeticiones, sin embargo, si no utilizas el break el for hará las 1000 repeticiones a pesar de haber encontrado el dato en la primera. La eficiencia en este caso cae notablemente. ¿Lo ves?
Bien, ya tenemos el dato y la posición guardada en pos, pero puede que te preguntes ¿Y si el dato no existe? En ese caso el bucle hará todas las repeticiones y nunca entrará dentro del if, por lo que el valor inicial de la variable pos no cambiará. Al finalizar todas las iteraciones del for la variable pos seguirá siendo -1.
Comprobación del resultado
Una vez que el for ha terminado su ejecución tendrás que comprobar el resultado para saber si existe el dato en el array o no. Para esto lo más sencillo es utilizar una instrucción if (línea 15).
Aplicando la lógica anterior, si el dato se encuentra en el array la variable pos tendrá el valor de la posición que ocupa, por lo que tendrá un valor mayor a igual a 0. Si no está en el array pos tendrá su valor inicial, es decir -1.
Como puedes comprobar la condición de la instrucción if es precisamente eso: if(pos>=0). Si esta condición se cumple el dato está en el array. Simplemente muestro un mensaje por pantalla que así lo indica. Aquí puedes ejecutar el código que necesites según tus necesidades en caso de que el dato exista.
El if tiene un else para contemplar también el caso contrario. Si la variable pos tiene valor -1 la condición pos>=0 será falsa, por lo que se ejecutará la instrucción encerrada dentro del else, en mi caso un mensaje que indica que el dato no existe. En tu caso puedes incluir aquí las instrucciones que necesites.
¿Está claro? Creo que es bastante sencillo. Ahora sigue leyendo para saber cómo buscar en un array ordenado.
Cómo buscar en un array ordenado
Cuando el array está ordenado la búsqueda es más eficiente, aunque no siempre partirás de un array ordenado, por lo que tal vez quieras ordenarlo primero. Si no sabes cómo ordenar un array revisa este artículo en el que te explico cómo hacerlo.
Partiendo de que el array ya está ordenado la forma más fácil de realizar la búsqueda es utilizar el método binarySearch() de la clase Arrays. Implementarlo manualmente es bastante más complejo y no te lo voy a explicar en este artículo.
Cómo buscar en un array ordenado con el método binarySearch()
El método binarySearch() de la clase Arrays realiza una búsqueda binaria. Este tipo de búsqueda reduce las iteraciones que se realizan para encontrar el dato, puesto que va acotando los elementos del array en función del dato a buscar.
¡No te asustes! Aunque la lógica es bastante más compleja que la de una búsqueda normal, Java ya nos lo da hecho y solo tendrás que llamar al método binarySearch() para que haga la búsqueda binaria por ti.
En el siguiente código de ejemplo te explico cómo utilizar binarySearch():
/* Declaraciones necesarias: */
int n = 9;
int [] nums = {2,2,4,4,7,9};
int pos = -1;
/* Búsqueda: */
pos = Arrays.binarySearch(nums, n);
/* Comprobación del resultado: */
if(pos >= 0){
System.out.println("Número encontrado en la posición "+pos);
}else{
System.out.println("No se ha encontrado el número");
}
No olvides importar la clase Arrays al inicio de tu código, sino te dará errores:
import java.util.Arrays;
Declaraciones necesarias
Tal y como vimos en el apartado anterior vas a necesitar tres variables: el dato a buscar (variable n), el array sobre el que realizar la búsqueda, que tendrá que estar ordenado (variable nums) y un entero en el que guardar la posición que ocupa el dato en caso de estar en el array (variable pos).
La lógica es la misma que en el caso de la búsqueda normal, si el dato existe en el array la variable pos tomará el valor de la primera posición en la que se encuentre dicho dato, en caso contrario la variable pos tomará un valor negativo.
Búsqueda
Fíjate ahora en la línea 7 del código. Como puedes comprobar llamo al método binarySearch() y le paso dos parámetros entre paréntesis: nums y n:
pos = Arrays.binarySearch(nums, n);
El primer parámetro es el array sobre el que se quiere realizar la búsqueda (recuerda que debe estar ordenado). El segundo parámetro es el dato que quiero buscar.
El método binarySearch() devuelve un entero positivo con la posición que ocupa el dato en el array, si existe. Si el dato está repetido siempre devolverá la posición del primero que encuentre. En caso de que el dato no exista devolverá un valor negativo. ¿Te suena esto? Es la lógica que describimos anteriormente.
El resultado devuelto por binarySearch() queda guardado en la variable pos puesto que lo estoy asignando. Esto será útil para realizar la comprobación después.
Comprobación del resultado
Una vez el resultado queda almacenado en la variable pos solo queda comprobar si este es negativo o no para saber si lo ha encontrado en el array.
Si te fijas, el código (línea 10) es el mismo que ya te expliqué en el apartado anterior por lo que no lo voy a volver a explicar. Pruébalo y comprueba que todo funciona correctamente.
Espero que este artículo te haya sido útil. Si estás aprendiendo Java no olvides revisar todo el contenido que tengo publicado sobre este lenguaje y no te pierdas el que publicaré próximamente.